From ff81e9999eb9c709dca51c6a6477d9581098080a Mon Sep 17 00:00:00 2001 From: Luqman Date: Sat, 7 Nov 2026 11:34:58 +0800 Subject: [PATCH] Keep each thread's last tool activity, and clear activity logs on logout Tool Activity was a single global list, wiped on every thread switch, new thread and re-attach, so the commands of a thread's last turn could not be reviewed afterwards. It is now stored per thread in localStorage, like the process console, together with the question it answered. Calls cut off by Stop show STOPPED instead of DONE; calls left running when the operator switches threads or closes the page show TERPUTUS and mark the list incomplete (re-attaching to a run still in progress replays it in full). Both logs hold tool arguments verbatim, so they no longer outlive the session on a shared browser: logout removes them, and logging in as a different user than the one who wrote them (e.g. after a session expired) clears them, in storage and in the copy already loaded by the chat screen. Co-Authored-By: Claude Opus 5.5 --- frontend/js/app.js | 3 +- frontend/js/screens/chat.js | 121 ++++++++++++++++++++++++++++++++---- frontend/js/shell.js | 28 +++++++++ frontend/js/state.js | 5 +- 4 files changed, 141 insertions(+), 16 deletions(-) diff --git a/frontend/js/app.js b/frontend/js/app.js index a5888c0..5dc2625 100644 --- a/frontend/js/app.js +++ b/frontend/js/app.js @@ -1,5 +1,5 @@ import { S } from './state.js'; -import { renderShell, renderNav } from './shell.js'; +import { renderShell, renderNav, claimActivityLogs } from './shell.js'; import { $ } from './utils.js'; import { NAV_ITEMS } from './config.js'; import { mgr } from './manager.js'; @@ -62,6 +62,7 @@ function onHash() { function startApp(user) { S.user = user.username; + claimActivityLogs(user.username); // before any screen reads the stored logs renderShell(); onHash(); window.addEventListener('hashchange', onHash); diff --git a/frontend/js/screens/chat.js b/frontend/js/screens/chat.js index 553e7b3..68bd963 100644 --- a/frontend/js/screens/chat.js +++ b/frontend/js/screens/chat.js @@ -23,6 +23,17 @@ const CONSOLE_MAX_ENTRIES = 500; const CONSOLE_MAX_THREADS = 30; let _consoleStore = {}; +let _logsCleared = false; // set on logout: stop persisting until the page reloads + +// Logout, or a different operator logging in on this browser: drop what was +// hydrated at module load, so it is neither shown nor written back. +window.addEventListener('activity-logs-cleared', e => { + _consoleStore = {}; + _toolStore = {}; + S.console = []; + S.tools = []; S.toolsQuery = ''; S.toolsPartial = false; + if (e.detail?.final) _logsCleared = true; +}); (function consoleHydrate() { try { @@ -37,6 +48,7 @@ let _consoleStore = {}; })(); function consoleSave() { + if (_logsCleared) return; try { localStorage.setItem(CONSOLE_STORAGE_KEY, JSON.stringify(_consoleStore)); } catch { /* storage full/unavailable — degrade to in-memory only */ } @@ -56,6 +68,66 @@ function consoleForThread(threadId) { return _consoleStore[key]; } +// ── Tool activity persistence — the last turn of each thread ────────────────── +// Kept per thread so switching threads, starting a new one or stopping a run +// does not wipe the commands an operator may want to review afterwards. Only the +// latest turn is kept; a new send/re-attach replaces it. S.tools references +// _toolStore[key].tools, so it is mutated in place like S.console. +const TOOLS_STORAGE_KEY = 'llmnetops-tools-v1'; +const TOOLS_MAX_THREADS = 30; + +let _toolStore = {}; + +(function toolsHydrate() { + try { + const raw = localStorage.getItem(TOOLS_STORAGE_KEY); + if (!raw) return; + for (const [key, turn] of Object.entries(JSON.parse(raw))) { + if (!turn || !Array.isArray(turn.tools)) continue; + // A call still "running" when the page went away has no known outcome any more. + const cut = turn.tools.some(t => t.state === 'running'); + turn.tools.forEach(t => { if (t.state === 'running') t.state = 'untracked'; }); + _toolStore[key] = { query: turn.query || '', tools: turn.tools, partial: !!turn.partial || cut }; + } + } catch { /* corrupt or unavailable — start empty */ } +})(); + +function toolsSave() { + if (_logsCleared) return; + try { + localStorage.setItem(TOOLS_STORAGE_KEY, JSON.stringify(_toolStore)); + } catch { /* storage full/unavailable — degrade to in-memory only */ } +} + +function toolsForThread(threadId) { + const key = consoleKey(threadId); + if (!_toolStore[key]) { + const keys = Object.keys(_toolStore); + if (keys.length >= TOOLS_MAX_THREADS) delete _toolStore[keys[0]]; + _toolStore[key] = { query: '', tools: [], partial: false }; + } + return _toolStore[key]; +} + +// Points S.tools at the stored last turn of the current thread. +function chatLoadTools() { + const turn = S.threadId ? toolsForThread(S.threadId) : { query: '', tools: [], partial: false }; + S.tools = turn.tools; + S.toolsQuery = turn.query; + S.toolsPartial = turn.partial; + chatRenderTools(); +} + +// Leaving a run that keeps going on the server: later calls are not recorded here +// (re-attaching while it still runs replays them all), so mark the list as cut off. +function chatMarkToolsUntracked() { + if (!S.threadId) return; + const turn = toolsForThread(S.threadId); + if (turn.tools.some(t => t.state === 'running')) turn.tools.forEach(t => { if (t.state === 'running') t.state = 'untracked'; }); + turn.partial = true; + toolsSave(); +} + function threadFromSummary(t) { return { id: t.id, title: t.title || 'New Chat', ts: t.updatedAt, createdAt: t.createdAt, lastMessage: t.lastMessage || '', owner: t.owner || '', running: !!t.running }; } @@ -103,6 +175,7 @@ export async function screenChat(c, threadIdParam) { const threadChanged = targetThreadId !== S.threadId; S.threadId = targetThreadId || null; S.console = S.threadId ? consoleForThread(S.threadId) : []; + if (threadChanged || S.chatState === 'idle') chatLoadTools(); chatSyncUrl(); c.innerHTML = ` @@ -246,7 +319,7 @@ async function chatAttach(threadId) { const lastUser = [...S.messages].reverse().find(m => m.role === 'user'); S.activeQuery = lastUser ? lastUser.content : ''; S.messages.push({ role: 'agent', content: '', ts: new Date(), streaming: true }); - chatResetTools(); + chatResetTools(S.activeQuery); chatStartElapsed(); _requestStartTs = Date.now(); _lastEventTs = null; @@ -281,7 +354,7 @@ function chatBindEvents() { S.activeQuery = text; S.messages.push({ role: 'user', content: text, ts: new Date() }); S.messages.push({ role: 'agent', content: '', ts: new Date(), streaming: true }); - chatResetTools(); + chatResetTools(text); chatStartElapsed(); _requestStartTs = Date.now(); _lastEventTs = null; @@ -323,6 +396,7 @@ function chatBindEvents() { S.console = consoleForThread(S.threadId); chatSyncUrl(); chatClear(); + chatLoadTools(); consoleRender(); }; btnL.onclick = async () => { @@ -371,7 +445,7 @@ function chatHandleEvent(ev) { break; case 'tool_start': S.tools.push({ name: ev.name, detail: ev.detail, state: 'running', durationMs: null }); - S.toolCount++; + toolsSave(); consolePush('tool_call', `${ev.name}${ev.detail ? ' ' + ev.detail : ''}`); chatRenderTools(); break; @@ -380,7 +454,8 @@ function chatHandleEvent(ev) { const running = [...S.tools].reverse().find(t => t.name === ev.name && t.state === 'running'); const state = ev.error ? 'failed' : 'done'; if (running) Object.assign(running, { state, durationMs: ev.durationMs }); - else { S.tools.push({ name: ev.name, detail: ev.detail, source: ev.source, state, durationMs: ev.durationMs }); S.toolCount++; } + else S.tools.push({ name: ev.name, detail: ev.detail, source: ev.source, state, durationMs: ev.durationMs }); + toolsSave(); consolePush(ev.error ? 'error' : 'tool_result', `${ev.name} (${fmtDelta(ev.durationMs || 0).slice(1)})${ev.detail ? ' → ' + ev.detail : ''}`); chatRenderTools(); @@ -428,21 +503,30 @@ function chatFinish() { consolePush('timing', `Total durasi: ${fmtDelta(Date.now() - _requestStartTs)}`); _requestStartTs = null; } - S.tools.forEach(t => { if (t.state === 'running') t.state = 'done'; }); + // chatUpdateUI() clears stopRequested below, so it still tells a stop from a normal end here. + const endState = S.stopRequested ? 'stopped' : 'done'; + S.tools.forEach(t => { if (t.state === 'running') t.state = endState; }); + toolsSave(); chatHideApproval(); chatRenderMessages(); chatRenderTools(); chatUpdateUI(); } function chatClear() { S.messages = []; S.activeQuery = ''; S.chatState = 'idle'; - chatResetTools(); chatStopElapsed(); chatRenderMessages(); chatRenderThreads(); chatUpdateUI(); } -function chatResetTools() { - S.tools = []; - S.toolCount = 0; +// Starts a new turn on the current thread, replacing its stored tool activity. +function chatResetTools(query) { + const turn = S.threadId ? toolsForThread(S.threadId) : { query: '', tools: [], partial: false }; + turn.tools.length = 0; // in place — keeps the _toolStore reference S.tools points at + turn.query = query || ''; + turn.partial = false; + S.tools = turn.tools; + S.toolsQuery = turn.query; + S.toolsPartial = false; + toolsSave(); chatRenderTools(); } @@ -468,17 +552,24 @@ function toolFull(detail) { function chatRenderTools() { const el = $('tool-panel'); if (!el) return; - const cnt = $('tool-count'); if (cnt) cnt.textContent = S.toolCount ? `${S.toolCount} call` : ''; + const cnt = $('tool-count'); if (cnt) cnt.textContent = S.tools.length ? `${S.tools.length} call` : ''; + // Outside a run the list is the thread's last turn, so say which question it belonged to. + const caption = S.chatState !== 'streaming' && S.toolsQuery + ? `

Giliran terakhir: ${esc(S.toolsQuery)}

` + + (S.toolsPartial ? '

Tidak lengkap: thread ditinggalkan saat proses masih berjalan.

' : '') + : ''; if (!S.tools.length) { - el.innerHTML = `

${S.chatState === 'streaming' ? 'Menunggu tool call...' : 'Belum ada tool call pada giliran ini.'}

`; + el.innerHTML = caption + `

${S.chatState === 'streaming' ? 'Menunggu tool call...' : 'Belum ada tool call pada giliran ini.'}

`; return; } const styles = { running: { dot: 'bg-green-500 pulse-green', text: 'text-green-700', label: 'RUNNING', bl: 'border-l-[3px] border-l-green-500' }, done: { dot: 'bg-gray-400', text: 'text-on-surface-variant', label: 'DONE', bl: '' }, failed: { dot: 'bg-red-500', text: 'text-red-700', label: 'FAILED', bl: 'border-l-[3px] border-l-red-500' }, + stopped: { dot: 'bg-amber-500', text: 'text-amber-700', label: 'STOPPED', bl: 'border-l-[3px] border-l-amber-500' }, + untracked: { dot: 'bg-gray-300', text: 'text-outline', label: 'TERPUTUS', bl: '' }, }; - el.innerHTML = S.tools.map(t => { + el.innerHTML = caption + S.tools.map(t => { const st = styles[t.state] || styles.done; const summary = toolSummary(t.detail); const child = t.source && t.source !== 'main' ? t.source.replace(/^child:/, '') : ''; @@ -736,6 +827,8 @@ async function chatDeleteThread(threadId, event) { S.threads = S.threads.filter(x => x.id !== threadId); delete _consoleStore[consoleKey(threadId)]; consoleSave(); + delete _toolStore[consoleKey(threadId)]; + toolsSave(); if (threadId !== S.threadId) { chatRenderThreads(); @@ -749,6 +842,7 @@ async function chatDeleteThread(threadId, event) { S.console = S.threadId ? consoleForThread(S.threadId) : []; chatSyncUrl(); chatClear(); + chatLoadTools(); consoleRender(); } } @@ -761,6 +855,7 @@ async function chatSwitchThread(threadId) { // server and stop following it; coming back re-attaches while it still runs. const backend = activeBackend(); if (!backend.detach) return; + chatMarkToolsUntracked(); backend.detach(S.threadId); S.chatState = 'idle'; S.pendingApproval = null; @@ -772,7 +867,7 @@ async function chatSwitchThread(threadId) { chatSyncUrl(); S.activeQuery = ''; S.chatState = 'idle'; - chatResetTools(); + chatLoadTools(); chatStopElapsed(); chatRenderThreads(); chatUpdateUI(); diff --git a/frontend/js/shell.js b/frontend/js/shell.js index 4bafd5f..4474eda 100644 --- a/frontend/js/shell.js +++ b/frontend/js/shell.js @@ -53,11 +53,39 @@ export function renderShell() { renderBackendIndicator(); $('logout-btn').onclick = async () => { try { await mgr('/auth/logout', { method: 'POST' }); } catch { /* the cookie is cleared server-side; reload either way */ } + clearActivityLogs({ final: true }); location.reload(); }; window.addEventListener('backend-changed', renderBackendIndicator); } +// Process console and tool activity hold the commands sent to routers (tool +// arguments verbatim), so they must not outlive the operator's session on a shared +// browser. Settings (backend, client name, profile) are kept. +const ACTIVITY_LOG_KEYS = ['llmnetops-console-v3', 'llmnetops-console-v2', 'llmnetops-tools-v1']; +const ACTIVITY_OWNER_KEY = 'llmnetops-activity-owner'; // username the stored logs belong to + +// `final` (logout): the page is about to reload, so the chat screen also stops +// persisting — a run still streaming must not write the logs back. +function clearActivityLogs({ final = false } = {}) { + window.dispatchEvent(new CustomEvent('activity-logs-cleared', { detail: { final } })); + for (const key of [...ACTIVITY_LOG_KEYS, ACTIVITY_OWNER_KEY]) { + try { localStorage.removeItem(key); } catch { /* storage unavailable — nothing persisted */ } + } +} + +// Called after login and on boot with a live session. A session that expired +// skips the logout button, so the logs of whoever used this browser before are +// still here: keep them only for that same operator. Logs with no recorded owner +// (written before owners were tracked) are treated as someone else's. +export function claimActivityLogs(username) { + let owner = null; + try { owner = localStorage.getItem(ACTIVITY_OWNER_KEY); } catch { /* treat as unknown */ } + if (owner === username) return; + clearActivityLogs(); + try { localStorage.setItem(ACTIVITY_OWNER_KEY, username); } catch { /* in-memory only */ } +} + // Header pill: active backend + reachability. Health is re-probed on every // render (shell load and backend switch), never on a timer. export async function renderBackendIndicator() { diff --git a/frontend/js/state.js b/frontend/js/state.js index 155c350..3cda299 100644 --- a/frontend/js/state.js +++ b/frontend/js/state.js @@ -9,8 +9,9 @@ export const S = { stopRequested: false, // true after operator clicks Stop, until run actually ends pendingApproval: null, activeQuery: '', - tools: [], // tool activity of the current turn: { name, detail, state, durationMs } - toolCount: 0, + tools: [], // tool activity of the thread's last turn: { name, detail, state, durationMs } + toolsQuery: '', // question that turn answered, shown above the list for review + toolsPartial: false, // the turn was left while running, so later calls are missing elapsed: 0, console: [], // persistent process log — survives across turns/threads consoleOpen: true,