claude-simple 0.2.6 → 0.2.8

package/src/app.js

@@ -18,6 +18,8 @@ import {
   scanAllSessions,
   loadSessionMessages,
   loadSessionMemory,
+  readSessionMemoryFile,
+  loadSessionJsonl,
   loadSessionUsage,
   searchActivity,
   groupByProject,
@@ -1008,19 +1010,37 @@ export function createApp() {
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
       };
-      const order = [...new Set([preferred, ...ENABLED_AGENTS, 'claude', 'codex', 'grok'].filter(Boolean))];
+      // A selected session already knows its agent. Do not fall back to another
+      // agent's account-level memory (especially Codex) when that session has none.
+      const order = preferred
+        ? [preferred]
+        : [...new Set([...ENABLED_AGENTS, 'claude', 'codex', 'grok'])];
       let memory = null;
       for (const a of order) {
         memory = await loadSessionMemory(sessionId, a, opts);
         if (memory) break;
       }
-      // Memory is Claude-centric; return empty instead of 404 so the tab doesn't hard-fail
-      res.json(memory || { index: null, files: [] });
+      res.json(memory || { agent: preferred || null, files: [] });
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
   });
 
+  app.get('/api/sessions/:sessionId/memory/file', authMiddleware, async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const agent = typeof req.query.agent === 'string' ? req.query.agent : 'claude';
+      const file = typeof req.query.file === 'string' ? req.query.file : '';
+      if (!/^[0-9a-f-]{36}$/i.test(sessionId)) return res.status(400).json({ error: 'Invalid session id' });
+      const row = await readSessionMemoryFile(sessionId, agent, file, {
+        claudeConfigDirs: CLAUDE_CONFIG_DIRS, codexHome: CODEX_HOME, grokHome: GROK_HOME,
+      });
+      if (!row) return res.status(404).json({ error: 'Memory file not found' });
+      res.setHeader('Cache-Control', 'private, max-age=30');
+      res.json(row);
+    } catch (e) { res.status(500).json({ error: e.message }); }
+  });
+
   app.get('/api/projects/:id/git/log', authMiddleware, async (req, res) => {
     try {
       const projectPath = resolveProjectRoot(req);
@@ -1044,10 +1064,12 @@ export function createApp() {
     listSessions,
     searchActivity,
     loadSessionMessages,
+    loadSessionJsonl,
     groupByProject,
     toClientSession,
     getProjectNotesStore: loadProjectNotes,
     saveProjectNotesStore: saveProjectNotes,
+    getSessionMetaStore: loadSessionMeta,
     normalizeProjectEntry,
     git,
     isGitRepo,
@@ -1122,6 +1144,50 @@ export function createApp() {
     }
   });
 
+  app.get('/api/ai/notes', authMiddleware, async (req, res) => {
+    try {
+      const limit = Math.min(parseInt(req.query.limit || '30', 10) || 30, 200);
+      const scope = typeof req.query.scope === 'string' ? req.query.scope : 'all';
+      const q = typeof req.query.q === 'string' ? req.query.q : '';
+      const cwd = typeof req.query.cwd === 'string' ? req.query.cwd : '';
+      const sessionId = typeof req.query.sessionId === 'string' ? req.query.sessionId : '';
+      const agent = typeof req.query.agent === 'string' ? req.query.agent : '';
+      res.json({
+        notes: await meta.listMetaNotes({ limit, scope, q, cwd, sessionId, agent }),
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.get('/api/ai/notes/:id', authMiddleware, async (req, res) => {
+    try {
+      const note = await meta.getMetaNote(req.params.id);
+      if (!note) return res.status(404).json({ error: 'not found' });
+      res.json(note);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/api/ai/notes', authMiddleware, async (req, res) => {
+    try {
+      const note = await meta.saveMetaNote(req.body || {});
+      res.json(note);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.delete('/api/ai/notes/:id', authMiddleware, async (req, res) => {
+    try {
+      const result = await meta.deleteMetaNote(req.params.id);
+      res.json(result);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   // SSE: generate work report
   app.post('/api/ai/report', authMiddleware, async (req, res) => {
     res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
@@ -1392,24 +1458,35 @@ export function createApp() {
         if (cmd.sessionId) options.sessionId = cmd.sessionId;
         if (cmd.cwd) options.cwd = cmd.cwd;
         if (options.sessionId) client.sessionId = options.sessionId;
-        const agentSend = createAgentSend(outbox, agent);
+        // A socket may subscribe to another session while this agent is still
+        // streaming. Keep this run's delivery target in its own closure rather
+        // than consulting mutable client.sessionId in the shared socket outbox.
+        let runSessionId = options.sessionId || client.sessionId || null;
+        const runOutbox = createOutbox((data) => {
+          broadcastChat(runSessionId, data, ws);
+        }, {
+          maxWait: 48,
+          maxDeltaChars: 720,
+          maxBatchItems: 10,
+          maxBatchBytes: 10_000,
+        });
+        const agentSend = createAgentSend(runOutbox, agent);
         const runSend = (data) => {
+          if (data?.sessionId) runSessionId = data.sessionId;
           if (data?.type === 'result' || data?.type === 'complete' || data?.type === 'error') {
-            markSessionIdle(data.sessionId || client.sessionId, options.sessionId);
-            outbox.flush();
+            markSessionIdle(data.sessionId || runSessionId, options.sessionId);
+            runOutbox.flush();
           }
-          if (data?.sessionId) client.sessionId = data.sessionId;
-          if (data?.type === 'session-created' && data.sessionId) client.sessionId = data.sessionId;
           // permission_request bypasses map filter double-pass carefully
           if (data?.type === 'permission_request' || data?.type === 'permission_resolved') {
-            outbox.send(data);
-            outbox.flush();
+            runOutbox.send(data);
+            runOutbox.flush();
             return;
           }
           agentSend(data);
         };
         await dispatchAgent(agent, cmd.command || '', options, runSend);
-        outbox.flush();
+        runOutbox.flush();
         return;
       }