@hype/clod 1.3.1 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/sessions.js CHANGED
@@ -1,65 +1,10 @@
1
- import { appendFile, readdir, readFile, stat, writeFile } from 'node:fs/promises';
2
1
  import { homedir } from 'node:os';
3
- import { basename, join } from 'node:path';
4
- import { trashPaths } from './trash.js';
5
- // Resolved lazily so tests can point $HOME at a fixture tree; os.homedir()
6
- // honors $HOME on posix, read afresh each call.
7
- const claudeDir = () => join(homedir(), '.claude');
8
- const projectsDir = () => join(claudeDir(), 'projects');
9
- // Claude Code injects system content as XML-tagged blocks; any message starting
10
- // with an opening tag is injected content, not a real user message
11
- const INJECTED = /^<[a-z]/i;
12
- // Claude Code writes "[Request interrupted by user]" and the like as user records
13
- const NOTICE = /^\[[^\]]*\]$/;
14
- // A slash command arrives as one injected block, with what the user typed inside
15
- // <command-args>; without this the whole prompt reads as system content.
16
- const COMMAND = /<command-name>([^<]*)<\/command-name>(?:\s*<command-args>([\s\S]*?)<\/command-args>)?/;
17
- function rawText(content) {
18
- if (typeof content === 'string')
19
- return content;
20
- if (Array.isArray(content))
21
- return content.find((b) => b.type === 'text')?.text ?? '';
22
- return '';
23
- }
24
- function userText(record) {
25
- if (record.type !== 'user' || record.isMeta)
26
- return null;
27
- const content = record.message?.content;
28
- if (hasRealText(content))
29
- return extractText(content);
30
- const m = COMMAND.exec(rawText(content));
31
- if (!m)
32
- return null;
33
- const args = m[2]?.trim();
34
- return args ? `${m[1].trim()} ${args}` : m[1].trim();
35
- }
36
- function hasRealText(content) {
37
- if (typeof content === 'string')
38
- return !INJECTED.test(content);
39
- if (Array.isArray(content))
40
- return content.some((b) => b.type === 'text' && !INJECTED.test(b.text ?? ''));
41
- return false;
42
- }
43
- export function extractText(content) {
44
- if (typeof content === 'string')
45
- return content;
46
- if (Array.isArray(content)) {
47
- return content.find((b) => b.type === 'text' && !INJECTED.test(b.text ?? ''))?.text ?? '';
48
- }
49
- return '';
50
- }
51
- // All text blocks of a message, joined; used to build the searchable content blob.
52
- export function textBlocks(content) {
53
- if (typeof content === 'string')
54
- return content;
55
- if (Array.isArray(content))
56
- return content
57
- .filter((b) => b.type === 'text')
58
- .map((b) => b.text ?? '')
59
- .join(' ');
60
- return '';
2
+ // Real throughput: new tokens processed + generated, excluding cache re-reads.
3
+ // Matches the figure shown in the shell status line.
4
+ export function throughputOf(usage) {
5
+ return (usage.input || 0) + (usage.output || 0) + (usage.cacheWrite || 0);
61
6
  }
62
- function modelKey(modelId) {
7
+ export function modelKey(modelId) {
63
8
  if (!modelId)
64
9
  return null;
65
10
  if (modelId.includes('opus'))
@@ -70,298 +15,6 @@ function modelKey(modelId) {
70
15
  return 'haiku';
71
16
  return null;
72
17
  }
73
- // Fold one assistant turn's usage into the per-model accumulator. cacheRead is
74
- // tracked apart: it re-counts the cached context every turn and dwarfs the rest
75
- // (~10x). Returns this turn's context size (input + cache), or null if no usage.
76
- function accumulateUsage(message, acc) {
77
- const u = message?.usage;
78
- if (!u)
79
- return null;
80
- const input = u.input_tokens || 0;
81
- const output = u.output_tokens || 0;
82
- const cacheRead = u.cache_read_input_tokens || 0;
83
- const cacheWrite = u.cache_creation_input_tokens || 0;
84
- const key = modelKey(message?.model);
85
- if (key) {
86
- acc[key] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
87
- const m = acc[key];
88
- m.input += input;
89
- m.output += output;
90
- m.cacheRead += cacheRead;
91
- m.cacheWrite += cacheWrite;
92
- }
93
- return input + cacheRead + cacheWrite;
94
- }
95
- // Real throughput: new tokens processed + generated, excluding cache re-reads.
96
- // Matches the figure shown in the shell status line.
97
- export function throughputOf(usage) {
98
- return (usage.input || 0) + (usage.output || 0) + (usage.cacheWrite || 0);
99
- }
100
- // last capture of re in str; re must have the g flag
101
- function matchLast(re, str) {
102
- let last = null;
103
- for (const m of str.matchAll(re))
104
- last = m[1]; // single capture group, always present on a match
105
- return last;
106
- }
107
- export async function parseSession(filePath, fileStats) {
108
- const sessionId = basename(filePath, '.jsonl');
109
- try {
110
- // Read as a Buffer and decode per line only as far as the sniff needs; skipped
111
- // lines (most of the bytes) are never decoded, which is the big startup cost.
112
- const buf = await readFile(filePath);
113
- let title = null;
114
- let cwd = null;
115
- let gitBranch = null;
116
- let firstUserMessage = null;
117
- let lastUserMessage = null;
118
- let lastTimestamp = null;
119
- let contextTokens = null; // input context of the most recent assistant turn
120
- const models = {};
121
- const searchParts = []; // prose for content search, lowercased at the end
122
- const setEnvelope = (ts, branch, dir) => {
123
- if (ts)
124
- lastTimestamp = ts;
125
- if (branch && branch !== 'HEAD')
126
- gitBranch = branch; // last-write: captures branch switches
127
- if (dir && !cwd)
128
- cwd = dir; // first-write: cwd doesn't change mid-session
129
- };
130
- // Most bytes are tool results and attachments clod never shows. Sniff each line's
131
- // head to decide whether to JSON.parse it; the sniff only gates parsing, so a
132
- // false positive costs one wasted parse, never wrong data. Assistant records
133
- // serialize "message" before "type", so their early marker is the message "role";
134
- // skipped lines get their envelope (timestamp/branch/cwd) from a tail regex.
135
- const NL = 10;
136
- for (let pos = 0, lineEnd = 0; pos < buf.length; pos = lineEnd + 1) {
137
- lineEnd = buf.indexOf(NL, pos);
138
- if (lineEnd === -1)
139
- lineEnd = buf.length;
140
- if (lineEnd === pos)
141
- continue;
142
- const head = buf.toString('utf8', pos, Math.min(pos + 600, lineEnd));
143
- const isAssistant = head.includes('"role":"assistant"') || head.includes('"type":"assistant"');
144
- const isUser = !isAssistant && (head.includes('"type":"user"') || head.includes('"role":"user"'));
145
- const isProse = isAssistant ||
146
- (isUser &&
147
- !head.includes('"isMeta":true') &&
148
- !head.includes('"tool_use_id"') &&
149
- !head.includes('"type":"tool_result"'));
150
- if (isProse) {
151
- try {
152
- const r = JSON.parse(buf.toString('utf8', pos, lineEnd));
153
- setEnvelope(r.timestamp, r.gitBranch, r.cwd);
154
- if (r.type === 'assistant') {
155
- const ctx = accumulateUsage(r.message, models); // usage on every turn, incl. tool-only
156
- if (ctx != null)
157
- contextTokens = ctx;
158
- searchParts.push(textBlocks(r.message?.content));
159
- }
160
- else {
161
- const text = userText(r);
162
- if (text !== null) {
163
- lastUserMessage = text;
164
- searchParts.push(text);
165
- const trimmed = text.trim();
166
- if (!firstUserMessage && trimmed && !NOTICE.test(trimmed))
167
- firstUserMessage = trimmed;
168
- }
169
- }
170
- }
171
- catch { }
172
- }
173
- else if (isUser ||
174
- head.includes('"type":"system"') ||
175
- /^\{"type":"(attachment|pr-link|queue-operation)"/.test(head)) {
176
- const tail = buf.toString('utf8', Math.max(pos, lineEnd - 400), lineEnd);
177
- setEnvelope(matchLast(/"timestamp":"([^"]+)"/g, tail), matchLast(/"gitBranch":"([^"]*)"/g, tail), matchLast(/"cwd":"([^"]*)"/g, tail));
178
- }
179
- else if (head.includes('"type":"custom-title"')) {
180
- try {
181
- const r = JSON.parse(buf.toString('utf8', pos, lineEnd));
182
- if (r.customTitle)
183
- title = r.customTitle;
184
- }
185
- catch { }
186
- }
187
- }
188
- if (!cwd)
189
- return null;
190
- const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
191
- for (const k in models) {
192
- totals.input += models[k].input;
193
- totals.output += models[k].output;
194
- totals.cacheRead += models[k].cacheRead;
195
- totals.cacheWrite += models[k].cacheWrite;
196
- }
197
- const throughput = throughputOf(totals);
198
- return {
199
- sessionId,
200
- title,
201
- cwd,
202
- gitBranch,
203
- firstUserMessage,
204
- lastUserMessage,
205
- contextTokens,
206
- models,
207
- totals,
208
- throughput,
209
- searchText: searchParts.join(' ').toLowerCase(),
210
- mtime: fileStats.mtimeMs,
211
- lastTimestamp: lastTimestamp ? new Date(lastTimestamp).getTime() : fileStats.mtimeMs,
212
- filePath
213
- };
214
- }
215
- catch {
216
- return null;
217
- }
218
- }
219
- // All session files with stats, newest first. mtime proxies the last record's
220
- // timestamp (files are append-only), so the head is what a recency sort needs first.
221
- export async function listSessionFiles() {
222
- let projects;
223
- try {
224
- projects = await readdir(projectsDir());
225
- }
226
- catch {
227
- return [];
228
- }
229
- const files = (await Promise.all(projects.map(async (project) => {
230
- const projectPath = join(projectsDir(), project);
231
- try {
232
- const names = await readdir(projectPath);
233
- return names.filter((f) => f.endsWith('.jsonl')).map((f) => join(projectPath, f));
234
- }
235
- catch {
236
- return [];
237
- }
238
- }))).flat();
239
- const stats = await Promise.all(files.map(async (filePath) => {
240
- try {
241
- return { filePath, stats: await stat(filePath) };
242
- }
243
- catch {
244
- return null;
245
- }
246
- }));
247
- return stats
248
- .filter((s) => s !== null)
249
- .sort((a, b) => b.stats.mtimeMs - a.stats.mtimeMs);
250
- }
251
- export async function parseSessions(files) {
252
- const sessions = await Promise.all(files.map((f) => parseSession(f.filePath, f.stats)));
253
- return sessions.filter((s) => s !== null);
254
- }
255
- export async function loadSessions() {
256
- const sessions = await parseSessions(await listSessionFiles());
257
- return sessions.sort((a, b) => b.lastTimestamp - a.lastTimestamp);
258
- }
259
- export async function getSessionMessages(filePath) {
260
- try {
261
- const raw = await readFile(filePath, 'utf8');
262
- const messages = [];
263
- for (const line of raw.split('\n').filter(Boolean)) {
264
- try {
265
- const r = JSON.parse(line);
266
- const text = userText(r);
267
- if (text !== null) {
268
- messages.push({ role: 'user', text, timestamp: r.timestamp });
269
- }
270
- else if (r.type === 'assistant') {
271
- const content = r.message?.content;
272
- let text = '';
273
- if (Array.isArray(content))
274
- text = content
275
- .filter((b) => b.type === 'text')
276
- .map((b) => b.text ?? '')
277
- .join('');
278
- else if (typeof content === 'string')
279
- text = content;
280
- if (text.trim())
281
- messages.push({ role: 'assistant', text: text.trim(), timestamp: r.timestamp });
282
- }
283
- }
284
- catch { }
285
- }
286
- return messages;
287
- }
288
- catch {
289
- return [];
290
- }
291
- }
292
- // Rename by appending the records Claude Code's /rename writes; the last one
293
- // wins on parse. custom-title feeds the resume picker, agent-name the title
294
- // shown inside a resumed session.
295
- export async function renameSession(filePath, title) {
296
- const sessionId = basename(filePath, '.jsonl');
297
- const records = [
298
- { type: 'custom-title', customTitle: title, sessionId },
299
- { type: 'agent-name', agentName: title, sessionId }
300
- ];
301
- await appendFile(filePath, records.map((r) => `${JSON.stringify(r)}\n`).join(''));
302
- }
303
- // Trash everything Claude Code keys by session id under ~/.claude, plus the
304
- // session's history.jsonl lines. Goes to Trash (recoverable). Skips plans/ and
305
- // paste-cache/ (shared) and sessions/<pid>.json (ephemeral).
306
- export async function deleteSession(filePath, trashFn = trashPaths) {
307
- const sessionId = basename(filePath, '.jsonl');
308
- const dir = claudeDir();
309
- const candidates = [
310
- filePath,
311
- filePath.replace(/\.jsonl$/, ''), // sibling dir (e.g. subagent transcripts)
312
- join(dir, 'tasks', sessionId),
313
- join(dir, 'file-history', sessionId),
314
- join(dir, 'session-env', sessionId),
315
- join(dir, 'debug', `${sessionId}.txt`)
316
- ];
317
- // telemetry is keyed by a filename prefix, not an exact path
318
- const telemetryDir = join(dir, 'telemetry');
319
- try {
320
- const prefix = `1p_failed_events.${sessionId}.`;
321
- for (const name of await readdir(telemetryDir)) {
322
- if (name.startsWith(prefix))
323
- candidates.push(join(telemetryDir, name));
324
- }
325
- }
326
- catch { }
327
- const toTrash = [];
328
- for (const p of candidates) {
329
- try {
330
- await stat(p);
331
- toTrash.push(p);
332
- }
333
- catch { }
334
- }
335
- await trashFn(toTrash);
336
- await scrubHistory(sessionId, trashFn);
337
- }
338
- // Remove the session's prompt lines from history.jsonl, writing the removed lines
339
- // to a file that's trashed too, so even this stays recoverable.
340
- async function scrubHistory(sessionId, trashFn) {
341
- const historyPath = join(claudeDir(), 'history.jsonl');
342
- let raw;
343
- try {
344
- raw = await readFile(historyPath, 'utf8');
345
- }
346
- catch {
347
- return;
348
- }
349
- const needle = `"sessionId":"${sessionId}"`;
350
- if (!raw.includes(needle))
351
- return;
352
- const kept = [];
353
- const removed = [];
354
- for (const line of raw.split('\n')) {
355
- if (line.includes(needle))
356
- removed.push(line);
357
- else
358
- kept.push(line);
359
- }
360
- const removedPath = join(claudeDir(), `history-removed-${sessionId}.jsonl`);
361
- await writeFile(removedPath, `${removed.join('\n')}\n`);
362
- await writeFile(historyPath, kept.join('\n'));
363
- await trashFn([removedPath]);
364
- }
365
18
  export const MONTHS = [
366
19
  'Jan',
367
20
  'Feb',
package/dist/ui.js CHANGED
@@ -1,17 +1,19 @@
1
- import { Box, Text, useApp, useInput, useStdout } from 'ink';
1
+ import { Box, Text, useApp, useInput, useWindowSize } from 'ink';
2
2
  import React from 'react';
3
3
  import { saveConfig } from './config.js';
4
- import { buildDisplayItems, computeNavigate, computePage, computeRowLayout, ctxStr, displayTitle, filterItems, findAdjacentSessionId, nextSortMode, pad, termSize, truncate, usedStr } from './list.js';
5
- import { deleteSession, fmtTokens, getSessionMessages, MONTHS, relativeTime, renameSession, shortPath } from './sessions.js';
4
+ import { deleteSession, getSessionMessages, HARNESSES, harnessOf, liveSessions, renameSession } from './harnesses/index.js';
5
+ import { buildDisplayItems, computeNavigate, computePage, computeRowLayout, ctxStr, displayTitle, filterItems, findAdjacentSessionId, GUTTER, nextSortMode, pad, truncate, usedStr, width } from './list.js';
6
+ import { fmtTokens, MONTHS, relativeTime, shortPath } from './sessions.js';
6
7
  import { bar, computeStats, sparkline } from './stats.js';
7
8
  const h = React.createElement;
8
- const { useState, useEffect, useMemo, memo } = React;
9
+ const { useState, useEffect, useMemo, useRef, memo } = React;
9
10
  const HINT_HEIGHT = 1;
10
11
  const HEADER_HEIGHT = 2;
11
12
  const SNIPPET_HEIGHT = 3;
13
+ const LIVE_REFRESH_MS = 5000;
12
14
  // ─── Row ─────────────────────────────────────────────────────────────────────
13
- const SessionRow = memo(function SessionRow({ session, selected, termWidth, sortMode, timeWidth, usedWidth, ctxWidth }) {
14
- const { title, titleFallback, branchCol, dirCol, usedCol, ctxCol, timeCol } = computeRowLayout({
15
+ const SessionRow = memo(function SessionRow({ session, selected, termWidth, sortMode, timeWidth, usedWidth, ctxWidth, live = false }) {
16
+ const { title, titleKind, branchCol, dirCol, usedCol, ctxCol, timeCol } = computeRowLayout({
15
17
  session,
16
18
  termWidth,
17
19
  sortMode,
@@ -19,61 +21,73 @@ const SessionRow = memo(function SessionRow({ session, selected, termWidth, sort
19
21
  usedWidth,
20
22
  ctxWidth
21
23
  });
24
+ // each harness's own glyph, lit while a running harness has the session open
25
+ const mark = harnessOf(session).mark;
22
26
  if (selected) {
23
27
  const branchPart = branchCol ? ` ${branchCol}` : '';
24
28
  const dirPart = dirCol ? ` ${dirCol}` : '';
25
29
  const rest = `${branchPart}${dirPart} ${usedCol} ${ctxCol} ${timeCol}`;
26
30
  const hl = { backgroundColor: 'grey', color: 'white', bold: true };
27
- return h(Box, {}, h(Text, hl, '> '), h(Text, { ...hl, bold: !titleFallback, italic: titleFallback }, title), h(Text, hl, pad(rest, Math.max(0, termWidth - 2 - title.length))));
31
+ return h(Box, {}, h(Text, hl, '>'), h(Text, live ? { ...hl, color: 'greenBright' } : hl, `${mark} `), h(Text, { ...hl, bold: titleKind === 'named', italic: titleKind === 'prompt' }, title), h(Text, hl, pad(rest, Math.max(0, termWidth - GUTTER - width(title)))));
28
32
  }
29
- return h(Box, { flexDirection: 'row' }, h(Text, {}, ' '), h(Text, { dimColor: titleFallback, italic: titleFallback }, title), branchCol ? h(Text, { color: 'yellow', dimColor: true }, ` ${branchCol}`) : null, dirCol ? h(Text, { color: 'cyan', dimColor: true }, ` ${dirCol}`) : null, h(Text, { dimColor: true }, ` ${usedCol}`), h(Text, { color: 'green', dimColor: true }, ` ${ctxCol}`), h(Text, { dimColor: true }, ` ${timeCol}`));
33
+ return h(Box, { flexDirection: 'row' }, h(Text, {}, ' '), h(Text, live ? { color: 'greenBright', bold: true } : { dimColor: true }, `${mark} `), h(Text, {
34
+ bold: titleKind === 'named',
35
+ dimColor: titleKind === 'prompt',
36
+ italic: titleKind === 'prompt'
37
+ }, title), branchCol ? h(Text, { color: 'yellow', dimColor: true }, ` ${branchCol}`) : null, dirCol ? h(Text, { color: 'cyan', dimColor: true }, ` ${dirCol}`) : null, h(Text, { dimColor: true }, ` ${usedCol}`), h(Text, { color: 'green', dimColor: true }, ` ${ctxCol}`), h(Text, { dimColor: true }, ` ${timeCol}`));
30
38
  });
31
39
  // ─── Row rename field ────────────────────────────────────────────────────────
32
- function InputText({ value, cursor, termWidth }) {
40
+ function InputText({ value, cursor, termWidth, mark }) {
33
41
  const style = { backgroundColor: 'grey', color: 'white', bold: true };
42
+ const chars = [...value];
43
+ const prefix = `>${mark} `;
34
44
  // Past the end there is no character to sit on: show a block instead
35
45
  // (ink trims trailing whitespace, so an inverse space would be invisible).
36
- if (cursor >= value.length) {
37
- return h(Box, {}, h(Text, style, pad(`> ${value}█`, termWidth)));
46
+ if (cursor >= chars.length) {
47
+ return h(Box, {}, h(Text, style, pad(`${prefix}${value}█`, termWidth)));
38
48
  }
39
49
  // The cursor is the inverse-video cell over the character it sits on.
40
- return h(Box, {}, h(Text, style, `> ${value.slice(0, cursor)}`), h(Text, { ...style, inverse: true }, value[cursor]), h(Text, style, pad(value.slice(cursor + 1), Math.max(0, termWidth - cursor - 3))));
50
+ return h(Box, {}, h(Text, style, `${prefix}${chars.slice(0, cursor).join('')}`), h(Text, { ...style, inverse: true }, chars[cursor]), h(Text, style, pad(chars.slice(cursor + 1).join(''), Math.max(0, termWidth - GUTTER - width(chars.slice(0, cursor + 1).join(''))))));
41
51
  }
42
52
  function openRename(title) {
43
- return { value: title, cursor: title.length };
53
+ return { value: title, cursor: width(title) };
44
54
  }
45
55
  function cursorLeft({ value, cursor }) {
46
56
  return { value, cursor: Math.max(0, cursor - 1) };
47
57
  }
48
58
  function cursorRight({ value, cursor }) {
49
- return { value, cursor: Math.min(value.length, cursor + 1) };
59
+ return { value, cursor: Math.min(width(value), cursor + 1) };
50
60
  }
51
61
  // Start of the word left of the cursor: skip spaces, then the word itself.
52
62
  function cursorPrevWord({ value, cursor }) {
63
+ const c = [...value];
53
64
  let i = cursor;
54
- while (i > 0 && value[i - 1] === ' ')
65
+ while (i > 0 && c[i - 1] === ' ')
55
66
  i--;
56
- while (i > 0 && value[i - 1] !== ' ')
67
+ while (i > 0 && c[i - 1] !== ' ')
57
68
  i--;
58
69
  return { value, cursor: i };
59
70
  }
60
71
  // Start of the word right of the cursor: skip the rest of this word, then spaces.
61
72
  function cursorNextWord({ value, cursor }) {
73
+ const c = [...value];
62
74
  let i = cursor;
63
- while (i < value.length && value[i] !== ' ')
75
+ while (i < c.length && c[i] !== ' ')
64
76
  i++;
65
- while (i < value.length && value[i] === ' ')
77
+ while (i < c.length && c[i] === ' ')
66
78
  i++;
67
79
  return { value, cursor: i };
68
80
  }
69
81
  function backspace({ value, cursor }) {
70
- const c = Math.max(0, cursor - 1);
71
- return { value: value.slice(0, c) + value.slice(cursor), cursor: c };
82
+ const c = [...value];
83
+ const at = Math.max(0, cursor - 1);
84
+ return { value: [...c.slice(0, at), ...c.slice(cursor)].join(''), cursor: at };
72
85
  }
73
86
  function insert({ value, cursor }, text) {
87
+ const c = [...value];
74
88
  return {
75
- value: value.slice(0, cursor) + text + value.slice(cursor),
76
- cursor: cursor + text.length
89
+ value: [...c.slice(0, cursor), text, ...c.slice(cursor)].join(''),
90
+ cursor: cursor + width(text)
77
91
  };
78
92
  }
79
93
  // ─── Directory header ─────────────────────────────────────────────────────────
@@ -85,11 +99,11 @@ function PreviewMode({ session, onBack, termWidth, termHeight, loadMessages }) {
85
99
  const [messages, setMessages] = useState(null);
86
100
  const [scroll, setScroll] = useState(0);
87
101
  useEffect(() => {
88
- loadMessages(session.filePath).then((msgs) => {
102
+ loadMessages(session).then((msgs) => {
89
103
  setMessages(msgs);
90
104
  setScroll(Math.max(0, msgs.length - 1));
91
105
  });
92
- }, [session.filePath, loadMessages]);
106
+ }, [session, loadMessages]);
93
107
  const viewHeight = termHeight - HEADER_HEIGHT - HINT_HEIGHT - 2;
94
108
  useInput((input, key) => {
95
109
  if (input === 'q' || input === ' ' || key.escape || key.backspace) {
@@ -129,8 +143,8 @@ function renderMessages(messages, scroll, viewHeight, termWidth) {
129
143
  function DeleteConfirm({ session, onConfirm, onCancel, termWidth, termHeight, loadMessages }) {
130
144
  const [messages, setMessages] = useState(null);
131
145
  useEffect(() => {
132
- loadMessages(session.filePath).then(setMessages);
133
- }, [session.filePath, loadMessages]);
146
+ loadMessages(session).then(setMessages);
147
+ }, [session, loadMessages]);
134
148
  useInput((input) => {
135
149
  if (input === 'y')
136
150
  onConfirm();
@@ -184,10 +198,9 @@ function StatsView({ sessions, onBack, termWidth, termHeight }) {
184
198
  const section = (label) => h(Box, { marginTop: 1 }, h(Text, { bold: true, color: 'cyan' }, label));
185
199
  return h(Box, { flexDirection: 'column' }, h(Box, { paddingX: 1 }, h(Text, { color: 'white', bold: true }, 'Usage · real throughput (cache reads excluded)')), h(Box, { paddingX: 1, flexDirection: 'column' }, h(Text, {}, `${stats.totalSessions} sessions `, h(Text, { color: 'green', bold: true }, `${fmtTokens(stats.totalThroughput)} throughput`), h(Text, { dimColor: true }, ` ${fmtTokens(stats.grandTotal)} incl. cache reads`)), section('Token breakdown'), ...bdRows.map((r) => h(Text, { key: r.label }, pad(r.label, labelW), h(Text, { color: r.label === 'Cache rd' ? 'gray' : 'green' }, bar(r.value, bdMax, barW)), h(Text, { dimColor: true }, ` ${fmtTokens(r.value)}`))), section('Throughput / day (30d)'), h(Text, {}, h(Text, { dimColor: true }, `${pad(sparkStart, 7)} `), h(Text, { color: 'green' }, spark), h(Text, { dimColor: true }, ` ${sparkEnd}`)), section('By model'), ...stats.byModel.map((m) => h(Text, { key: m.name }, pad(m.name, labelW), h(Text, { color: 'green' }, bar(m.throughput, modelMax, barW)), h(Text, { dimColor: true }, ` ${fmtTokens(m.throughput)}`))), section('Top projects by throughput'), ...projects.map((p) => h(Text, { key: p.cwd }, pad(truncate(shortPath(p.cwd), projLabelW), projLabelW), ' ', h(Text, { color: 'green' }, bar(p.throughput, projMax, barW)), h(Text, { dimColor: true }, ` ${fmtTokens(p.throughput)}`)))), h(Box, { marginTop: 1 }, h(Text, { dimColor: true }, 'q/esc/u back')));
186
200
  }
187
- export default function App({ loadFirst, loadRest, initialSortMode, onResume, onDelete = deleteSession, onRename = renameSession, loadMessages = getSessionMessages }) {
201
+ export default function App({ loadFirst, loadRest, initialSortMode, onResume, onDelete = deleteSession, onRename = renameSession, loadMessages = getSessionMessages, onSaveConfig = saveConfig, loadLive = liveSessions, liveRefreshMs = LIVE_REFRESH_MS }) {
188
202
  const { exit } = useApp();
189
- const { stdout } = useStdout();
190
- const { width: termWidth, height: termHeight } = termSize(stdout);
203
+ const { columns: termWidth, rows: termHeight } = useWindowSize();
191
204
  const [sessions, setSessions] = useState([]);
192
205
  const [selectedId, setSelectedId] = useState(null);
193
206
  const [viewStart, setViewStart] = useState(0);
@@ -198,6 +211,27 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
198
211
  const [rename, setRename] = useState(null);
199
212
  const [error, setError] = useState(null);
200
213
  const [loading, setLoading] = useState(true);
214
+ const [harness, setHarness] = useState(null);
215
+ const [live, setLive] = useState(new Set());
216
+ const sessionsRef = useRef(sessions);
217
+ sessionsRef.current = sessions;
218
+ // Which sessions a running harness has open, read off the render path once the
219
+ // list has loaded and then on an interval. Rename and delete check afresh.
220
+ useEffect(() => {
221
+ if (loading)
222
+ return;
223
+ let stopped = false;
224
+ const refresh = () => loadLive(sessionsRef.current).then((ids) => {
225
+ if (!stopped)
226
+ setLive(ids);
227
+ }, () => { });
228
+ refresh();
229
+ const timer = setInterval(refresh, liveRefreshMs);
230
+ return () => {
231
+ stopped = true;
232
+ clearInterval(timer);
233
+ };
234
+ }, [loading]);
201
235
  // Paint before any session is parsed: newest batch first, the rest in one later
202
236
  // batch (disjoint from the first, so a delete can't be resurrected by the merge).
203
237
  useEffect(() => {
@@ -216,7 +250,8 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
216
250
  const timeWidth = useMemo(() => sessions.reduce((m, s) => Math.max(m, relativeTime(s.lastTimestamp).length), 4), [sessions]);
217
251
  const usedWidth = useMemo(() => sessions.reduce((m, s) => Math.max(m, usedStr(s).length), 1), [sessions]);
218
252
  const ctxWidth = useMemo(() => sessions.reduce((m, s) => Math.max(m, ctxStr(s).length), 1), [sessions]);
219
- const displayItems = useMemo(() => buildDisplayItems(sessions, sortMode), [sessions, sortMode]);
253
+ const shown = useMemo(() => (harness ? sessions.filter((s) => s.harness === harness) : sessions), [sessions, harness]);
254
+ const displayItems = useMemo(() => buildDisplayItems(shown, sortMode), [shown, sortMode]);
220
255
  const filteredItems = useMemo(() => filterItems(displayItems, searchQuery), [displayItems, searchQuery]);
221
256
  const selectedIdx = useMemo(() => filteredItems.findIndex((item) => item.type === 'session' && item.session.sessionId === selectedId), [filteredItems, selectedId]);
222
257
  const currentItem = filteredItems[selectedIdx];
@@ -258,12 +293,20 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
258
293
  if (key.return) {
259
294
  const title = rename.value.trim();
260
295
  setRename(null);
261
- if (current && title && title !== (current.title || 'Untitled')) {
296
+ // confirming an unchanged auto title keeps it as the user's own
297
+ if (current &&
298
+ title &&
299
+ title !== (current.title || (current.aiTitle ? null : 'Untitled'))) {
262
300
  // update the row in the same frame the input closes
263
301
  const updateRow = (s) => s.sessionId === current.sessionId ? { ...s, title } : s;
264
302
  setSessions((cur) => cur.map(updateRow));
265
303
  // persist in the background; revert and warn if it fails
266
- onRename(current.filePath, title).catch((err) => {
304
+ onRename(current, title).then((stored) => {
305
+ if (stored === title)
306
+ return;
307
+ const storedRow = (s) => s.sessionId === current.sessionId ? { ...s, title: stored } : s;
308
+ setSessions((cur) => cur.map(storedRow));
309
+ }, (err) => {
267
310
  const revertRow = (s) => s.sessionId === current.sessionId ? { ...s, title: current.title } : s;
268
311
  setSessions((cur) => cur.map(revertRow));
269
312
  setError(`could not save rename: ${err.message}`);
@@ -350,12 +393,18 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
350
393
  setMode('preview');
351
394
  else if (input === 'u')
352
395
  setMode('stats');
396
+ else if (input === 'h') {
397
+ // all -> each harness in turn -> all
398
+ const ids = HARNESSES.map((x) => x.id);
399
+ setHarness(harness === null ? ids[0] : (ids[ids.indexOf(harness) + 1] ?? null));
400
+ setViewStart(0);
401
+ }
353
402
  else if (key.return && current) {
354
403
  onResume(current);
355
404
  exit();
356
405
  }
357
406
  else if (input === 'r' && current) {
358
- setRename(openRename(current.title || 'Untitled'));
407
+ setRename(openRename(current.title || current.aiTitle || 'Untitled'));
359
408
  }
360
409
  else if (input === 'D' && current)
361
410
  setMode('deleting');
@@ -363,7 +412,7 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
363
412
  const next = nextSortMode(sortMode);
364
413
  setSortMode(next);
365
414
  setViewStart(0);
366
- saveConfig({ sortMode: next }); // persist for next launch (fire and forget)
415
+ onSaveConfig({ sortMode: next }); // persist for next launch (fire and forget)
367
416
  }
368
417
  else if (input === 'q' || key.escape)
369
418
  exit();
@@ -380,7 +429,7 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
380
429
  }
381
430
  if (mode === 'stats') {
382
431
  return h(StatsView, {
383
- sessions,
432
+ sessions: shown,
384
433
  onBack: () => setMode('list'),
385
434
  termWidth,
386
435
  termHeight
@@ -393,7 +442,7 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
393
442
  termHeight,
394
443
  onConfirm: async () => {
395
444
  try {
396
- await onDelete(current.filePath);
445
+ await onDelete(current);
397
446
  }
398
447
  catch (err) {
399
448
  setError(`could not delete: ${err.message}`);
@@ -427,15 +476,16 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
427
476
  recent: 'sorted by most recent',
428
477
  lexic: 'sorted lexicographically'
429
478
  };
479
+ const harnessLabel = harness ? HARNESSES.find((x) => x.id === harness)?.name : 'all harnesses';
430
480
  const matchCount = filteredItems.filter((i) => i.type === 'session').length;
431
481
  // searchQuery is only ever non-empty while searching, so the label tracks isSearching
432
482
  const searchLabel = isSearching ? ` │ /${searchQuery}█ ${matchCount} matches` : '';
433
483
  const headerText = pad(sessions.length === 0 && loading
434
484
  ? ' clod │ loading sessions…'
435
- : ` clod │ ${sessions.length}${loading ? '+' : ''} sessions │ ${sortLabel[sortMode]}${searchLabel}${loading ? ' │ loading…' : ''}`, termWidth);
485
+ : ` clod │ ${shown.length}${loading ? '+' : ''} sessions │ ${harnessLabel} │ ${sortLabel[sortMode]}${searchLabel}${loading ? ' │ loading…' : ''}`, termWidth);
436
486
  const navText = pad(rename !== null
437
487
  ? ' enter confirm esc cancel'
438
- : ' ↑↓ nav / search space preview enter resume r rename u usage s sort D delete q quit', termWidth);
488
+ : ' ↑↓ nav / search space preview enter resume r rename u usage s sort h harness D delete q quit', termWidth);
439
489
  return h(Box, { flexDirection: 'column' }, h(Box, {
440
490
  borderStyle: 'single',
441
491
  borderLeft: false,
@@ -451,12 +501,14 @@ export default function App({ loadFirst, loadRest, initialSortMode, onResume, on
451
501
  key: item.session.sessionId,
452
502
  value: rename.value,
453
503
  cursor: rename.cursor,
454
- termWidth
504
+ termWidth,
505
+ mark: harnessOf(item.session).mark
455
506
  })
456
507
  : h(SessionRow, {
457
508
  key: item.session.sessionId,
458
509
  session: item.session,
459
510
  selected: item.session.sessionId === selectedId,
511
+ live: live.has(item.session.sessionId),
460
512
  termWidth,
461
513
  sortMode,
462
514
  timeWidth,