@portel/photon 1.11.0 → 1.12.0

package/dist/daemon/server.js

@@ -21,6 +21,9 @@ import { createLogger } from '../shared/logger.js';
 import { getErrorMessage } from '../shared/error-handler.js';
 import { timingSafeEqual, readBody, SimpleRateLimiter } from '../shared/security.js';
 import { audit } from '../shared/audit.js';
+import fastJsonPatch from 'fast-json-patch';
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const jsonPatchCompare = fastJsonPatch.compare;
 // Command line args: socketPath (global daemon only needs socket path)
 const socketPath = process.argv[2];
 const logger = createLogger({
@@ -592,6 +595,10 @@ async function getOrCreateSessionManager(photonName, photonPath, workingDir) {
         manager = new SessionManager(pathToUse, photonName, idleTimeout, logger.child({ scope: photonName }), workingDir);
         sessionManagers.set(key, manager);
         photonPaths.set(key, pathToUse);
+        // Also store under bare photonName so snapshotState/persistInstanceState can find it
+        if (!photonPaths.has(photonName)) {
+            photonPaths.set(photonName, pathToUse);
+        }
         if (workingDir) {
             workingDirs.set(key, workingDir);
             watchWorkingDir(workingDir);
@@ -1034,6 +1041,68 @@ async function handleRequest(request, socket) {
                     data: { instances, current, autoInstance, metadata },
                 };
             }
+            // ── Undo / Redo ──────────────────────────────────────────────
+            if (request.method === '_undo' || request.method === '_redo') {
+                const isUndo = request.method === '_undo';
+                const instanceLabel = session.instanceName || 'default';
+                const key = undoKey(photonName, instanceLabel);
+                const source = isUndo ? undoPast.get(key) : undoFuture.get(key);
+                const dest = isUndo ? undoFuture : undoPast;
+                if (!source || source.length === 0) {
+                    return {
+                        type: 'result',
+                        id: request.id,
+                        success: true,
+                        data: { error: `Nothing to ${isUndo ? 'undo' : 'redo'}` },
+                    };
+                }
+                const entry = source.pop();
+                const opsToApply = isUndo ? entry.inversePatch : entry.patch;
+                // Apply patch to live instance
+                await applyPatchToInstance(session.instance, photonName, opsToApply);
+                // Persist the new state
+                await persistInstanceState(session.instance, photonName, session.instanceName, request.workingDir);
+                // Push to opposite stack
+                let destStack = dest.get(key);
+                if (!destStack) {
+                    destStack = [];
+                    dest.set(key, destStack);
+                }
+                destStack.push(entry);
+                // Generate the resulting patch for this undo/redo action
+                const actionPatch = isUndo ? entry.inversePatch : entry.patch;
+                const actionInverse = isUndo ? entry.patch : entry.inversePatch;
+                const stateChangedPayload = {
+                    event: 'state-changed',
+                    method: request.method,
+                    params: { undoneMethod: entry.method },
+                    instance: instanceLabel,
+                    data: { method: entry.method, action: isUndo ? 'undo' : 'redo' },
+                    ...(actionPatch.length > 0 && { patch: actionPatch }),
+                    ...(actionInverse.length > 0 && { inversePatch: actionInverse }),
+                    uri: `photon://${photonName}/${instanceLabel}`,
+                };
+                // Publish to instance-specific channel for multi-instance isolation
+                publishToChannel(`${photonName}:${instanceLabel}:state-changed`, stateChangedPayload, socket);
+                // Log undo/redo to event log
+                await appendEventLog(photonName, instanceLabel, {
+                    method: request.method,
+                    params: { undoneMethod: entry.method },
+                    instance: instanceLabel,
+                    patch: actionPatch,
+                    inversePatch: actionInverse,
+                }, request.workingDir);
+                return {
+                    type: 'result',
+                    id: request.id,
+                    success: true,
+                    data: {
+                        action: isUndo ? 'undo' : 'redo',
+                        method: entry.method,
+                        message: `${isUndo ? 'Undid' : 'Redid'} "${entry.method}"`,
+                    },
+                };
+            }
             // ─────────────────────────────────────────────────────────────
             // ── Instance-scoped execution (one-shot, no session mutation) ──
             // If targetInstance is set, load that instance, execute on it,
@@ -1053,6 +1122,8 @@ async function handleRequest(request, socket) {
                         publishToChannel(emit.channel, emit, socket);
                     }
                 };
+                // Snapshot state before execution for JSON Patch diffing
+                const preSnapshot = await snapshotState(targetInst, photonName);
                 const startTime = Date.now();
                 const result = await sessionManager.loader.executeTool(targetInst, request.method, request.args || {}, { outputHandler });
                 const durationMs = Date.now() - startTime;
@@ -1076,12 +1147,41 @@ async function handleRequest(request, socket) {
                     durationMs,
                 });
                 await persistInstanceState(targetInst, photonName, targetName, request.workingDir);
-                publishToChannel(`${photonName}:state-changed`, {
+                // Generate JSON Patch (RFC 6902) forward + inverse ops
+                const postSnapshot = preSnapshot ? await snapshotState(targetInst, photonName) : null;
+                const patch = preSnapshot && postSnapshot ? jsonPatchCompare(preSnapshot, postSnapshot) : [];
+                const inversePatch = preSnapshot && postSnapshot ? jsonPatchCompare(postSnapshot, preSnapshot) : [];
+                const instanceLabel = targetName || 'default';
+                const stateChangedPayload = {
                     event: 'state-changed',
                     method: request.method,
-                    instance: targetName,
+                    params: request.args || {},
+                    instance: instanceLabel,
                     data: result,
-                }, socket);
+                    ...(patch.length > 0 && { patch }),
+                    ...(inversePatch.length > 0 && { inversePatch }),
+                    uri: `photon://${photonName}/${instanceLabel}`,
+                };
+                // Publish to instance-specific channel for multi-instance isolation
+                publishToChannel(`${photonName}:${instanceLabel}:state-changed`, stateChangedPayload, socket);
+                // Append to event log
+                if (patch.length > 0) {
+                    await appendEventLog(photonName, instanceLabel, {
+                        method: request.method,
+                        params: request.args || {},
+                        instance: instanceLabel,
+                        patch,
+                        inversePatch,
+                    }, request.workingDir);
+                }
+                // Track for undo/redo
+                if (patch.length > 0) {
+                    pushUndoEntry(photonName, instanceLabel, {
+                        method: request.method,
+                        patch,
+                        inversePatch,
+                    });
+                }
                 return { type: 'result', id: request.id, success: true, data: result, durationMs };
             }
             logger.info('Executing request', {
@@ -1097,6 +1197,8 @@ async function handleRequest(request, socket) {
                     logger.debug('Published to channel', { channel: emit.channel });
                 }
             };
+            // Snapshot state before execution for JSON Patch diffing
+            const preSnapshot = await snapshotState(session.instance, photonName);
             const startTime = Date.now();
             const result = await sessionManager.loader.executeTool(session.instance, request.method, request.args || {}, { outputHandler });
             const durationMs = Date.now() - startTime;
@@ -1121,12 +1223,42 @@ async function handleRequest(request, socket) {
             });
             // Persist reactive state after each tool call
             await persistInstanceState(session.instance, photonName, session.instanceName, request.workingDir);
-            // Notify subscribers that state may have changed
-            publishToChannel(`${photonName}:state-changed`, {
+            // Generate JSON Patch (RFC 6902) forward + inverse ops
+            const postSnapshot = preSnapshot ? await snapshotState(session.instance, photonName) : null;
+            const patch = preSnapshot && postSnapshot ? jsonPatchCompare(preSnapshot, postSnapshot) : [];
+            const inversePatch = preSnapshot && postSnapshot ? jsonPatchCompare(postSnapshot, preSnapshot) : [];
+            const instanceLabel = session.instanceName || 'default';
+            const stateChangedPayload = {
                 event: 'state-changed',
                 method: request.method,
+                params: request.args || {},
+                instance: instanceLabel,
                 data: result,
-            }, socket);
+                ...(patch.length > 0 && { patch }),
+                ...(inversePatch.length > 0 && { inversePatch }),
+                uri: `photon://${photonName}/${instanceLabel}`,
+            };
+            // Notify subscribers that state may have changed (instance-specific channel)
+            const targetLabel = session.instanceName || 'default';
+            publishToChannel(`${photonName}:${targetLabel}:state-changed`, stateChangedPayload, socket);
+            // Append to event log
+            if (patch.length > 0) {
+                await appendEventLog(photonName, instanceLabel, {
+                    method: request.method,
+                    params: request.args || {},
+                    instance: instanceLabel,
+                    patch,
+                    inversePatch,
+                }, request.workingDir);
+            }
+            // Track for undo/redo
+            if (patch.length > 0) {
+                pushUndoEntry(photonName, instanceLabel, {
+                    method: request.method,
+                    patch,
+                    inversePatch,
+                });
+            }
             return { type: 'result', id: request.id, success: true, data: result, durationMs };
         }
         catch (error) {
@@ -1193,6 +1325,34 @@ async function getStateKeys(photonName, photonPath) {
         return [];
     }
 }
+/**
+ * Capture a JSON-serializable snapshot of a photon instance's state.
+ * Returns null for non-stateful photons (no state keys).
+ * Used for JSON Patch diffing (pre/post execution).
+ */
+async function snapshotState(instance, photonName) {
+    const photonPath = photonPaths.get(photonName);
+    if (!photonPath)
+        return null;
+    const keys = await getStateKeys(photonName, photonPath);
+    if (keys.length === 0)
+        return null;
+    const target = instance?.instance ?? instance;
+    const snapshot = {};
+    for (const key of keys) {
+        const value = target[key];
+        if (value === undefined)
+            continue;
+        if (value && typeof value === 'object' && value._propertyName) {
+            snapshot[key] = value.toJSON ? value.toJSON() : globalThis.Array.from(value);
+        }
+        else {
+            snapshot[key] = value;
+        }
+    }
+    // Deep-clone to freeze the snapshot (avoid reference sharing with live state)
+    return JSON.parse(JSON.stringify(snapshot));
+}
 /**
  * Persist reactive collection state to disk after each tool call.
  * Only persists properties identified as 'state' injection type
@@ -1240,6 +1400,143 @@ async function persistInstanceState(instance, photonName, instanceName, workingD
     }
 }
 // ════════════════════════════════════════════════════════════════════════════════
+// EVENT LOG (JSONL append-only per instance)
+// ════════════════════════════════════════════════════════════════════════════════
+/** Monotonically increasing sequence number per photon:instance */
+const eventLogSeq = new Map();
+const EVENT_LOG_MAX_SIZE = parseInt(process.env.PHOTON_EVENT_LOG_MAX_SIZE || '', 10) || 10 * 1024 * 1024; // 10MB default
+/**
+ * Get the event log path for a photon instance.
+ * Co-located with state file: ~/.photon/state/{photon}/{instance}.log
+ */
+function getInstanceLogPath(photonName, instanceName, baseDir) {
+    const name = instanceName || 'default';
+    const dir = baseDir || getDefaultContext().baseDir;
+    return path.join(dir, 'state', photonName, `${name}.log`);
+}
+/**
+ * Append an event entry to the JSONL event log.
+ * Handles log rotation when file exceeds EVENT_LOG_MAX_SIZE.
+ */
+async function appendEventLog(photonName, instanceName, entry, workingDir) {
+    try {
+        const logPath = getInstanceLogPath(photonName, instanceName, workingDir);
+        const fsPromises = await import('fs/promises');
+        await fsPromises.mkdir(path.dirname(logPath), { recursive: true });
+        // Get next sequence number
+        const seqKey = `${photonName}:${instanceName}`;
+        const seq = (eventLogSeq.get(seqKey) || 0) + 1;
+        eventLogSeq.set(seqKey, seq);
+        const logEntry = {
+            seq,
+            timestamp: new Date().toISOString(),
+            method: entry.method,
+            params: entry.params,
+            instance: entry.instance,
+            patch: entry.patch,
+            inversePatch: entry.inversePatch,
+        };
+        const line = JSON.stringify(logEntry) + '\n';
+        // Check rotation before appending
+        try {
+            const stat = await fsPromises.stat(logPath);
+            if (stat.size >= EVENT_LOG_MAX_SIZE) {
+                const rotatedPath = logPath + '.1';
+                await fsPromises.rename(logPath, rotatedPath).catch(() => { });
+                logger.debug('Rotated event log', { photon: photonName, instance: instanceName });
+            }
+        }
+        catch {
+            // File doesn't exist yet — that's fine
+        }
+        await fsPromises.appendFile(logPath, line);
+        logger.debug('Appended event log', { photon: photonName, instance: instanceName, seq });
+    }
+    catch (error) {
+        logger.error('Failed to append event log', {
+            photon: photonName,
+            error: getErrorMessage(error),
+        });
+    }
+}
+/** past stack per photon:instance */
+const undoPast = new Map();
+/** future stack per photon:instance */
+const undoFuture = new Map();
+const UNDO_STACK_LIMIT = 100;
+function undoKey(photonName, instance) {
+    return `${photonName}:${instance || 'default'}`;
+}
+function pushUndoEntry(photonName, instance, entry) {
+    const key = undoKey(photonName, instance);
+    let past = undoPast.get(key);
+    if (!past) {
+        past = [];
+        undoPast.set(key, past);
+    }
+    past.push(entry);
+    if (past.length > UNDO_STACK_LIMIT)
+        past.shift();
+    // New mutation clears the redo future
+    undoFuture.set(key, []);
+}
+/**
+ * Apply a JSON Patch to a live photon instance's state.
+ * Snapshots state as plain JSON, applies patch, then rehydrates instance properties.
+ */
+async function applyPatchToInstance(instance, photonName, ops) {
+    // Use the already-imported fastJsonPatch module
+    const applyPatch = fastJsonPatch.applyPatch.bind(fastJsonPatch);
+    const photonPath = photonPaths.get(photonName);
+    if (!photonPath)
+        return;
+    const keys = await getStateKeys(photonName, photonPath);
+    if (keys.length === 0)
+        return;
+    // Get current state as plain JSON
+    const snapshot = await snapshotState(instance, photonName);
+    if (!snapshot)
+        return;
+    // Apply patch operations
+    applyPatch(snapshot, ops, true, true);
+    // Rehydrate instance properties from patched snapshot
+    const target = instance?.instance ?? instance;
+    for (const key of keys) {
+        if (!(key in snapshot))
+            continue;
+        const current = target[key];
+        const patched = snapshot[key];
+        if (current && typeof current === 'object' && current._propertyName) {
+            // ReactiveArray — clear and replace contents
+            if (typeof current.splice === 'function') {
+                current.splice(0, current.length, ...patched);
+            }
+            else if (current instanceof Map || (current.clear && current.set)) {
+                current.clear();
+                for (const [k, v] of Object.entries(patched))
+                    current.set(k, v);
+            }
+            else if (current instanceof Set || (current.clear && current.add)) {
+                current.clear();
+                for (const v of patched)
+                    current.add(v);
+            }
+        }
+        else if (globalThis.Array.isArray(current)) {
+            current.splice(0, current.length, ...patched);
+        }
+        else if (typeof current === 'object' && current !== null) {
+            // Plain object — replace properties
+            for (const k of Object.keys(current))
+                delete current[k];
+            Object.assign(current, patched);
+        }
+        else {
+            target[key] = patched;
+        }
+    }
+}
+// ════════════════════════════════════════════════════════════════════════════════
 // FILE WATCHING (Auto Hot-Reload)
 // ════════════════════════════════════════════════════════════════════════════════
 function watchPhotonFile(photonName, photonPath) {