@portel/photon 1.19.0 → 1.20.1

package/dist/auto-ui/streamable-http-transport.js

@@ -68,6 +68,28 @@ function decodeJWTCaller(authHeader) {
 const sessions = new Map();
 const pendingElicitations = new Map();
 const APPROVALS_DIR = join(homedir(), '.photon', 'state');
+// Simple async mutex for file operations
+function createMutex() {
+    let locked = Promise.resolve();
+    return {
+        async acquire(fn) {
+            let release;
+            const next = new Promise((resolve) => {
+                release = resolve;
+            });
+            const prev = locked;
+            locked = next;
+            await prev;
+            try {
+                return await fn();
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}
+const approvalsMutex = createMutex();
 function approvalsPath(photonName) {
     return join(APPROVALS_DIR, photonName, 'approvals.json');
 }
@@ -92,18 +114,22 @@ async function saveApprovals(photonName, approvals) {
     await writeFile(approvalsPath(photonName), JSON.stringify(approvals, null, 2));
 }
 async function addApproval(approval) {
-    const approvals = await loadApprovals(approval.photon);
-    approvals.push(approval);
-    await saveApprovals(approval.photon, approvals);
+    return approvalsMutex.acquire(async () => {
+        const approvals = await loadApprovals(approval.photon);
+        approvals.push(approval);
+        await saveApprovals(approval.photon, approvals);
+    });
 }
 async function resolveApproval(photonName, approvalId, status) {
-    const approvals = await loadApprovals(photonName);
-    const idx = approvals.findIndex((a) => a.id === approvalId);
-    if (idx === -1)
-        return undefined;
-    approvals[idx].status = status;
-    await saveApprovals(photonName, approvals);
-    return approvals[idx];
+    return approvalsMutex.acquire(async () => {
+        const approvals = await loadApprovals(photonName);
+        const idx = approvals.findIndex((a) => a.id === approvalId);
+        if (idx === -1)
+            return undefined;
+        approvals[idx].status = status;
+        await saveApprovals(photonName, approvals);
+        return approvals[idx];
+    });
 }
 async function getAllPendingApprovals(photonNames) {
     const all = [];
@@ -146,16 +172,114 @@ function parseDurationToMs(duration) {
             return 5 * 60 * 1000;
     }
 }
+// ── Elicitation lifecycle helpers ──
+/** Duration before an unanswered elicitation moves to pending approvals */
+const ELICITATION_DEFER_MS = 30_000; // 30 seconds
+/** Maximum time an elicitation stays alive in pending queue */
+const ELICITATION_EXPIRY_MS = 30 * 60 * 1000; // 30 minutes
+/** Interval between progress keepalive broadcasts */
+const KEEPALIVE_INTERVAL_MS = 25_000; // 25 seconds (under 30s SDK default)
+/** Clean up all timers associated with a pending elicitation */
+function cleanupElicitation(pending) {
+    if (pending.timer)
+        clearTimeout(pending.timer);
+    if (pending.deferTimer)
+        clearTimeout(pending.deferTimer);
+    if (pending.keepaliveInterval)
+        clearInterval(pending.keepaliveInterval);
+}
+/**
+ * Set up two-phase timeout for an elicitation:
+ * Phase 1 (30s): Modal shown to user. If no response, move to pending queue.
+ * Phase 2 (30min): Keepalive progress notifications sent. Final expiry cancels.
+ */
+function setupElicitationTimeout(elicitationId, pending, resolve) {
+    const photon = pending.photonName || 'unknown';
+    const method = pending.methodName || 'unknown';
+    const message = pending.message || 'Approval required';
+    // Phase 1: After 30s without response, defer to pending queue
+    pending.deferTimer = setTimeout(() => {
+        // Only defer if still pending (user may have responded)
+        if (!pendingElicitations.has(elicitationId))
+            return;
+        const approvalId = elicitationId; // reuse ID for linking
+        pending.approvalId = approvalId;
+        const expiresAt = new Date(Date.now() + ELICITATION_EXPIRY_MS).toISOString();
+        // Write to persistent approval storage (fire-and-forget, non-blocking)
+        void addApproval({
+            id: approvalId,
+            photon,
+            method,
+            message,
+            status: 'pending',
+            createdAt: new Date().toISOString(),
+            expiresAt,
+        });
+        // Tell Beam frontend to close modal and show badge
+        broadcastToBeam('beam/elicitation-deferred', {
+            elicitationId,
+            approvalId,
+            photon,
+            method,
+            message,
+            expiresAt,
+        });
+        // Start progress keepalives to prevent external MCP client timeout
+        pending.keepaliveInterval = setInterval(() => {
+            if (!pendingElicitations.has(elicitationId)) {
+                if (pending.keepaliveInterval)
+                    clearInterval(pending.keepaliveInterval);
+                return;
+            }
+            broadcastNotification('notifications/progress', {
+                progressToken: `approval_${elicitationId}`,
+                progress: 0,
+                total: 0,
+                message: `Waiting for user approval: ${message}`,
+            });
+        }, KEEPALIVE_INTERVAL_MS);
+        // Phase 2: Final expiry after 30 minutes
+        pending.timer = setTimeout(() => {
+            if (pendingElicitations.has(elicitationId)) {
+                cleanupElicitation(pending);
+                pendingElicitations.delete(elicitationId);
+                // Mark approval as expired on disk
+                void resolveApproval(photon, approvalId, 'rejected');
+                // Notify frontend
+                broadcastToBeam('beam/approval-resolved', {
+                    approvalId,
+                    photon,
+                    status: 'expired',
+                });
+                resolve({ action: 'cancel' });
+            }
+        }, ELICITATION_EXPIRY_MS);
+    }, ELICITATION_DEFER_MS);
+}
 // Clean up old sessions periodically (30 min timeout)
 const SESSION_TIMEOUT_MS = 30 * 60 * 1000;
-setInterval(() => {
-    const now = Date.now();
-    for (const [id, session] of sessions) {
-        if (now - session.lastActivity.getTime() > SESSION_TIMEOUT_MS) {
-            sessions.delete(id);
+let sessionCleanupInterval = null;
+function startSessionCleanup() {
+    if (sessionCleanupInterval)
+        return;
+    sessionCleanupInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [id, session] of sessions) {
+            if (now - session.lastActivity.getTime() > SESSION_TIMEOUT_MS) {
+                sessions.delete(id);
+            }
         }
+    }, 60 * 1000);
+    sessionCleanupInterval.unref();
+}
+export function stopSessionCleanup() {
+    if (sessionCleanupInterval) {
+        clearInterval(sessionCleanupInterval);
+        sessionCleanupInterval = null;
     }
-}, 60 * 1000);
+}
+// Start cleanup on module load
+startSessionCleanup();
 function getOrCreateSession(sessionId) {
     if (sessionId && sessions.has(sessionId)) {
         const session = sessions.get(sessionId);
@@ -506,8 +630,17 @@ const handlers = {
             };
         }
         pendingElicitations.delete(elicitationId);
-        if (pending.timer)
-            clearTimeout(pending.timer);
+        cleanupElicitation(pending);
+        // If this elicitation was deferred to approvals, resolve the approval on disk too
+        if (pending.approvalId) {
+            const status = params?.cancelled ? 'rejected' : 'approved';
+            await resolveApproval(pending.photonName || 'unknown', pending.approvalId, status);
+            broadcastToBeam('beam/approval-resolved', {
+                approvalId: pending.approvalId,
+                photon: pending.photonName || 'unknown',
+                status,
+            });
+        }
         if (params?.cancelled) {
             pending.reject(new Error('Elicitation cancelled by user'));
         }
@@ -540,8 +673,7 @@ const handlers = {
         const pending = pendingElicitations.get(params.approvalId);
         if (pending) {
             pendingElicitations.delete(params.approvalId);
-            if (pending.timer)
-                clearTimeout(pending.timer);
+            cleanupElicitation(pending);
             if (params.approved) {
                 pending.resolve(true);
             }
@@ -630,11 +762,19 @@ const handlers = {
                     inputSchema: method.params || { type: 'object', properties: {} },
                     'x-photon-id': photon.id, // Unique ID (hash of path) for subscriptions
                     'x-photon-path': photon.path, // File path for View Source
+                    // Editable when the photon file sits directly in the base dir (user-owned).
+                    // Marketplace-installed photons live in a subdirectory and are read-only.
+                    'x-photon-editable': photon.path
+                        ? dirname(photon.path) === (ctx.workingDir || '')
+                        : false,
                     'x-photon-description': photon.description,
                     'x-photon-icon': photon.icon,
                     'x-photon-internal': photon.internal,
                     'x-photon-stateful': photon.stateful || false,
                     'x-photon-has-settings': photon.hasSettings || false,
+                    'x-photon-short-name': photon.shortName,
+                    'x-photon-namespace': photon.namespace,
+                    'x-photon-qualified-name': photon.qualifiedName,
                     'x-photon-install-source': photon.installSource,
                     'x-photon-prompt-count': photon.promptCount ?? 0,
                     'x-photon-resource-count': photon.resourceCount ?? 0,
@@ -1111,7 +1251,7 @@ const handlers = {
             const elicitResult = await requestBeamElicitation({
                 ask: 'confirm',
                 message: `"${methodName}" is a destructive operation. Continue?`,
-            });
+            }, { photonName: serverName, methodName });
             if (elicitResult.action !== 'accept' || elicitResult.content === false) {
                 return {
                     jsonrpc: '2.0',
@@ -1155,7 +1295,7 @@ const handlers = {
                         ask: 'select',
                         message: 'Select an instance',
                         options: selectOptions,
-                    });
+                    }, { photonName: serverName, methodName });
                     if (elicitResult.action !== 'accept' || !elicitResult.content) {
                         return {
                             jsonrpc: '2.0',
@@ -1173,7 +1313,7 @@ const handlers = {
                             ask: 'text',
                             message: 'Enter a name for the new instance',
                             placeholder: 'e.g. groceries, work, personal',
-                        });
+                        }, { photonName: serverName, methodName });
                         if (nameResult.action !== 'accept' || !nameResult.content) {
                             return {
                                 jsonrpc: '2.0',
@@ -2052,7 +2192,7 @@ const handlers = {
         }
         // If input_required right now, handle elicitation before waiting
         if (task.state === 'input_required' && task.input) {
-            const elicitResult = await requestBeamElicitation(task.input);
+            const elicitResult = await requestBeamElicitation(task.input, { photonName: task.photon || 'task', methodName: task.method || taskId });
             if (elicitResult.action === 'accept') {
                 resolveTaskInput(taskId, elicitResult.content);
             }
@@ -2073,7 +2213,7 @@ const handlers = {
                 }
                 if (current.state === 'input_required' && current.input) {
                     // Send elicitation to the client
-                    const elicitResult = await requestBeamElicitation(current.input);
+                    const elicitResult = await requestBeamElicitation(current.input, { photonName: task.photon || 'task', methodName: task.method || taskId });
                     if (elicitResult.action === 'accept') {
                         resolveTaskInput(taskId, elicitResult.content);
                     }
@@ -2360,7 +2500,7 @@ async function handleBeamRemove(req, ctx, args) {
     const elicitResult = await requestBeamElicitation({
         ask: 'confirm',
         message: `Remove "${photonName}"? The photon and its assets will be moved to trash.`,
-    });
+    }, { photonName, methodName: 'remove' });
     if (elicitResult.action !== 'accept' || elicitResult.content === false) {
         return {
             jsonrpc: '2.0',
@@ -3368,8 +3508,7 @@ export function sendToSession(sessionId, method, params) {
  */
 export function requestExternalElicitation(mcpName, request) {
     const elicitationId = randomUUID();
-    return new Promise((resolve, reject) => {
-        // Store pending elicitation
+    return new Promise((resolve) => {
         const pending = {
             resolve: (value) => {
                 resolve({ action: 'accept', content: value });
@@ -3382,7 +3521,10 @@ export function requestExternalElicitation(mcpName, request) {
                     resolve({ action: 'decline' });
                 }
             },
-            sessionId: '', // External MCP elicitations aren't tied to a specific session
+            sessionId: '',
+            photonName: mcpName,
+            methodName: 'elicitation',
+            message: request.message,
         };
         pendingElicitations.set(elicitationId, pending);
         // Broadcast elicitation request to all Beam clients
@@ -3394,13 +3536,8 @@ export function requestExternalElicitation(mcpName, request) {
             schema: request.requestedSchema,
             url: request.url,
         });
-        // Timeout after 5 minutes (timer cleared on normal resolve)
-        pending.timer = setTimeout(() => {
-            if (pendingElicitations.has(elicitationId)) {
-                pendingElicitations.delete(elicitationId);
-                resolve({ action: 'cancel' });
-            }
-        }, 300000);
+        // Two-phase timeout: 30s modal → pending queue with keepalives → 30min expiry
+        setupElicitationTimeout(elicitationId, pending, resolve);
     });
 }
 /**
@@ -3408,7 +3545,7 @@ export function requestExternalElicitation(mcpName, request) {
  * Unlike requestExternalElicitation which uses MCP form/url mode, this sends
  * the ask type directly so the elicitation modal renders the appropriate UI.
  */
-function requestBeamElicitation(data) {
+function requestBeamElicitation(data, context) {
     const elicitationId = randomUUID();
     return new Promise((resolve) => {
         const pending = {
@@ -3424,6 +3561,9 @@ function requestBeamElicitation(data) {
                 }
             },
             sessionId: '',
+            photonName: context?.photonName,
+            methodName: context?.methodName,
+            message: data.message,
         };
         pendingElicitations.set(elicitationId, pending);
         // Broadcast with Photon-native ask format (not MCP form mode)
@@ -3431,13 +3571,8 @@ function requestBeamElicitation(data) {
             elicitationId,
             ...data,
         });
-        // Timeout after 5 minutes (timer cleared on normal resolve)
-        pending.timer = setTimeout(() => {
-            if (pendingElicitations.has(elicitationId)) {
-                pendingElicitations.delete(elicitationId);
-                resolve({ action: 'cancel' });
-            }
-        }, 300000);
+        // Two-phase timeout: 30s modal → pending queue with keepalives → 30min expiry
+        setupElicitationTimeout(elicitationId, pending, resolve);
     });
 }
 //# sourceMappingURL=streamable-http-transport.js.map