claude-simple 0.2.27 → 0.2.28

package/public/style.css

@@ -1830,6 +1830,122 @@ html.settings-open #app { visibility: hidden; }
   .set-nav-item { white-space: nowrap; }
 }
 
+/* ── Personal notes (main pane, sidebar stays) ────────────────────────────── */
+
+.notes-page {
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  padding: 16px clamp(12px, 3vw, 32px) 24px;
+  gap: 12px;
+  overflow-y: auto;
+  background: hsl(var(--b1));
+  color: hsl(var(--bc));
+}
+.notes-page[hidden] { display: none !important; }
+.notes-count {
+  margin: 4px 0 0;
+  font-size: 12px;
+  color: hsl(var(--bc) / .55);
+}
+.notes-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  border-bottom: 1px solid hsl(var(--b3) / .35);
+  padding-bottom: 12px;
+}
+.notes-header h2 {
+  margin: 0;
+  font-size: 1.4rem;
+  letter-spacing: .02em;
+}
+.notes-header-actions { display: flex; gap: 8px; }
+.notes-add {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 12px;
+  border-radius: 12px;
+  background: hsl(var(--b2));
+  border: 1px solid hsl(var(--b3) / .4);
+}
+.notes-add textarea,
+.notes-edit-text {
+  width: 100%;
+  font: inherit;
+  background: hsl(var(--b1));
+  color: inherit;
+  border: 1px solid hsl(var(--b3) / .4);
+  border-radius: 8px;
+  padding: 10px 12px;
+  resize: vertical;
+  min-height: 80px;
+}
+.notes-form-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+.notes-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+.notes-empty {
+  padding: 28px;
+  text-align: center;
+  color: hsl(var(--bc) / .55);
+  border: 1px dashed hsl(var(--b3) / .45);
+  border-radius: 12px;
+}
+.notes-error { color: hsl(var(--er) / .85); border-color: hsl(var(--er) / .35); }
+.notes-item {
+  background: hsl(var(--b2));
+  border: 1px solid hsl(var(--b3) / .35);
+  border-radius: 12px;
+  padding: 14px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.notes-text {
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-size: .98rem;
+  line-height: 1.55;
+}
+.notes-meta {
+  font-size: .75rem;
+  color: hsl(var(--bc) / .55);
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+.notes-item-foot {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.notes-item-actions {
+  display: flex;
+  gap: 4px;
+  margin-left: auto;
+}
+.btn.danger {
+  background: hsl(var(--er) / .15);
+  color: hsl(var(--er));
+  border: 1px solid hsl(var(--er) / .35);
+}
+.btn.primary {
+  background: hsl(var(--p));
+  color: hsl(var(--pc));
+  border: 1px solid hsl(var(--p) / .85);
+}
+
 /* Overlays must not eat keystrokes when hidden */
 #sidebar-overlay.hidden,
 .mermaid-zoom-overlay.hidden,
@@ -1847,3 +1963,43 @@ html.settings-open #app { visibility: hidden; }
   cursor: not-allowed;
   opacity: .78;
 }
+
+.notes-add[hidden] { display: none; }
+.notes-error { color: #ef4444; }
+
+.notes-item {
+  background: rgba(255255255, .04);
+  border: 1px solid rgba(255255255, .08);
+  border-radius: 8px;
+  padding: 12px;
+}
+.notes-text {
+  white-space: pre-wrap;
+  word-break: break-word;
+  line-height: 1.55;
+}
+.notes-meta {
+  margin-top: 8px;
+  color: rgba(255255255, .4);
+  font-size: 11px;
+  display: flex;
+  gap: 6px;
+}
+.notes-item-actions {
+  margin-top: 8px;
+  display: flex;
+  gap: 6px;
+  justify-content: flex-end;
+}
+.notes-edit-text {
+  width: 100%;
+  resize: vertical;
+  min-height: 60px;
+  background: transparent;
+  color: inherit;
+  border: 1px solid rgba(255255255, .08);
+  border-radius: 6px;
+  padding: 6px 8px;
+  font-family: inherit;
+  font-size: 14px;
+}

package/public/sw.js

@@ -1,7 +1,7 @@
 /* Agent UI service worker — cache shell assets only.
  * Never intercepts WebSocket or mutates API semantics beyond offline fallback.
  * Bump CACHE when shipping UI that must invalidate old shells. */
-const CACHE = 'agent-ui-shell-v27';
+const CACHE = 'agent-ui-shell-v28';
 const PRECACHE = [
   '/',
   '/index.html',

package/src/agents/grok.js

@@ -388,8 +388,24 @@ function clientFor(options, cliPath) {
   return client;
 }
 
+export function grokActivityStatus(update) {
+  const kind = update?.sessionUpdate;
+  if (kind === 'tool_call' || kind === 'tool_call_update') {
+    const name = update.title || update.kind || 'tool';
+    const st = update.status ? ` (${update.status})` : '';
+    return `Grok 工具: ${name}${st}`;
+  }
+  if (kind === 'agent_thought_chunk') return 'Grok 正在思考…';
+  if (kind === 'agent_message_chunk') return '';
+  return 'Grok ACP running…';
+}
+
 function emitUpdate(update, send, state) {
   const kind = update?.sessionUpdate;
+  const activity = grokActivityStatus(update);
+  if (activity) {
+    send({ type: 'status', message: activity, agent: 'grok' });
+  }
   if (kind === 'agent_message_chunk' && update.content?.text) {
     if (state.thoughtOpen) {
       send({ type: 'thought_stream_end', agent: 'grok' });

package/src/agents/sessions.js

@@ -496,6 +496,105 @@ async function forkCodexNativeSession(sourceSessionId, targetSessionId, codexHom
   return targetFile;
 }
 
+function grokAssistantText(record) {
+  if (record?.type !== 'assistant') return '';
+  return extractGrokText(record.content).trim();
+}
+
+function grokUpdateKind(record) {
+  const update = record?.params?.update || record?.update || {};
+  return update.sessionUpdate || update.type || '';
+}
+
+function grokUpdateText(record) {
+  const update = record?.params?.update || record?.update || {};
+  return extractGrokText(update.content).trim();
+}
+
+/**
+ * Grok resumes from a session directory, not a synthetic chat transcript.
+ * Fork by cloning the native files and cutting both journals at the selected
+ * assistant reply so tool results and encrypted reasoning stay intact.
+ */
+async function forkGrokNativeSession(sourceSessionId, targetSessionId, grokHome, assistantText, occurrence) {
+  const sourceDir = await findGrokSessionDir(sourceSessionId, grokHome);
+  if (!sourceDir) throw new Error('Grok source session was not found');
+
+  const sourceHistory = await fs.readFile(path.join(sourceDir, 'chat_history.jsonl'), 'utf8');
+  const historyOut = [];
+  let foundForkPoint = false;
+  let seenMatches = 0;
+  for (const line of sourceHistory.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let record;
+    try { record = JSON.parse(line); } catch { continue; }
+    historyOut.push(JSON.stringify(replaceSessionId(record, sourceSessionId, targetSessionId)));
+    const text = grokAssistantText(record);
+    if (text && text === assistantText && ++seenMatches === occurrence) {
+      foundForkPoint = true;
+      break;
+    }
+  }
+  if (!foundForkPoint) {
+    throw new Error('Selected Grok assistant message was not found in the native transcript');
+  }
+
+  const targetDir = path.join(path.dirname(sourceDir), targetSessionId);
+  await fs.mkdir(targetDir, { recursive: true });
+  const histTmp = path.join(targetDir, `chat_history.jsonl.tmp-${crypto.randomUUID()}`);
+  await fs.writeFile(histTmp, `${historyOut.join('\n')}\n`, 'utf8');
+  await fs.rename(histTmp, path.join(targetDir, 'chat_history.jsonl'));
+
+  try {
+    const sourceUpdates = await fs.readFile(path.join(sourceDir, 'updates.jsonl'), 'utf8');
+    const updatesOut = [];
+    let acc = '';
+    let seenUpdateMatches = 0;
+    let matched = false;
+    for (const line of sourceUpdates.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      let record;
+      try { record = JSON.parse(line); } catch { continue; }
+      const kind = grokUpdateKind(record);
+      if (matched && (kind === 'user_message_chunk' || kind === 'agent_message_chunk')) break;
+      updatesOut.push(JSON.stringify(replaceSessionId(record, sourceSessionId, targetSessionId)));
+      if (kind === 'agent_message_chunk') {
+        acc = `${acc}${grokUpdateText(record)}`;
+        if (acc.trim() === assistantText && ++seenUpdateMatches === occurrence) matched = true;
+      } else if (kind === 'user_message_chunk' || kind === 'turn_completed') {
+        acc = '';
+      }
+    }
+    const updTmp = path.join(targetDir, `updates.jsonl.tmp-${crypto.randomUUID()}`);
+    await fs.writeFile(updTmp, updatesOut.length ? `${updatesOut.join('\n')}\n` : '', 'utf8');
+    await fs.rename(updTmp, path.join(targetDir, 'updates.jsonl'));
+  } catch {}
+
+  const copyNames = ['system_prompt.txt', 'prompt_context.json', 'resources_state.json', 'announcement_state.json', 'signals.json'];
+  for (const name of copyNames) {
+    try {
+      const raw = await fs.readFile(path.join(sourceDir, name), 'utf8');
+      let out = raw;
+      if (name.endsWith('.json')) {
+        try { out = JSON.stringify(replaceSessionId(JSON.parse(raw), sourceSessionId, targetSessionId), null, 2); }
+        catch { out = raw.replaceAll(sourceSessionId, targetSessionId); }
+      }
+      await fs.writeFile(path.join(targetDir, name), out, 'utf8');
+    } catch {}
+  }
+
+  try {
+    const summaryRaw = await fs.readFile(path.join(sourceDir, 'summary.json'), 'utf8');
+    const summary = replaceSessionId(JSON.parse(summaryRaw), sourceSessionId, targetSessionId);
+    if (summary.info && typeof summary.info === 'object') summary.info.id = targetSessionId;
+    else summary.info = { ...(summary.info || {}), id: targetSessionId };
+    summary.updated_at = new Date().toISOString();
+    await fs.writeFile(path.join(targetDir, 'summary.json'), JSON.stringify(summary, null, 2), 'utf8');
+  } catch {}
+
+  return targetDir;
+}
+
 // ─── Grok ─────────────────────────────────────────────────────────────────────
 
 export async function scanGrokSessions(grokHome, filterCwd = null) {
@@ -1654,10 +1753,10 @@ export async function readSessionMemoryFile(sessionId, agent, fileId, opts) {
 }
 
 /** Return bounded raw JSONL for a particular agent session, for Meta Agent analysis. */
-export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset = 0, maxLines = 500 } = {}) {
+export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset = 0, maxLines = 500, tail = false, maxChars = 24000 } = {}) {
   if (!agent) {
     for (const candidate of ['claude', 'codex', 'grok', 'gemini', 'cursor']) {
-      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset, maxLines });
+      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset, maxLines, tail, maxChars });
       if (found) return found;
     }
     return null;
@@ -1673,20 +1772,35 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
     file = dir ? path.join(dir, 'chat_history.jsonl') : null;
   } else file = await findClaudeSessionFile(sessionId, claudeConfigDirs);
   if (!file) return null;
-  const start = Math.max(0, Number(offset) || 0);
-  const limit = Math.min(Math.max(1, Number(maxLines) || 500), 2000);
+  const start = Math.max(0, Math.floor(Number(offset) || 0));
+  const limit = Math.min(Math.max(1, Math.floor(Number(maxLines) || 100)), 500);
+  const budget = Math.min(Math.max(1000, Number(maxChars) || 24000), 64000);
   const lines = [];
-  let n = 0;
-  let hasMore = false;
+  let n = 0, chars = 0, hasMore = false, clipped = false;
   const stream = fsSync.createReadStream(file, { encoding: 'utf8' });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-  for await (const line of rl) {
-    if (n++ < start) continue;
-    if (lines.length >= limit) { hasMore = true; rl.close(); stream.destroy(); break; }
-    lines.push(line);
-  }
+  try {
+    for await (const line of rl) {
+      const index = n++;
+      if (!tail && index < start) continue;
+      if (!tail && (lines.length >= limit || chars >= budget)) { hasMore = true; break; }
+      // Bound huge tool output rows as well as total response size. Clipping
+      // is explicit: a clipped line must not be mistaken for complete JSON.
+      const cap = tail ? budget : budget - chars;
+      const text = line.slice(0, cap);
+      if (text.length < line.length) clipped = true;
+      lines.push(text); chars += text.length;
+      if (tail) while (lines.length > limit || (chars > budget && lines.length > 1)) {
+        chars -= lines.shift().length;
+      }
+    }
+  } finally { rl.close(); stream.destroy(); }
   const stat = await fs.stat(file).catch(() => null);
-  return { agent: a, fileName: path.basename(file), offset: start, lines, nextOffset: start + lines.length, truncated: hasMore, size: stat?.size || 0 };
+  const actualOffset = tail ? Math.max(0, n - lines.length) : start;
+  return { agent: a, fileName: path.basename(file), offset: actualOffset, lines,
+    nextOffset: actualOffset + lines.length, truncated: hasMore, clipped,
+    tail, size: stat?.size || 0, updatedAt: stat?.mtimeMs || null };
+
 }
 
 export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
@@ -1796,6 +1910,17 @@ export async function convertSession(sourceSessionId, sourceAgent, targetAgent,
     } catch {}
     return { targetSessionId };
   }
+
+  if (ta === 'grok' && sourceAgent.toLowerCase() === 'grok' && Number.isInteger(upTo)) {
+    const selected = messages[messages.length - 1];
+    if (selected?.role !== 'assistant' || !selected.content?.trim()) {
+      throw new Error('A Grok fork must end at a persisted assistant message');
+    }
+    const occurrence = messages.filter(message => message.role === 'assistant'
+      && message.content?.trim() === selected.content.trim()).length;
+    await forkGrokNativeSession(sourceSessionId, targetSessionId, grokHome, selected.content.trim(), occurrence);
+    return { targetSessionId };
+  }
   
   if (ta === 'claude') {
     const configDir = claudeConfigDirs?.[0] || path.join(os.homedir(), '.claude');

package/src/app.js

@@ -37,6 +37,7 @@ import { createExternalSessionMirror } from './runtime/external-session-sync.js'
 import { resolveApproval, cancelApprovalsForSession } from './runtime/approvals.js';
 import { createMcpHttpHandler, createMcpService } from './mcp.js';
 import { createCollab, roleAtLeast, proxyToLocalPort, machineId as localMachineId } from './collab.js';
+import { parseHistoryQuery, sliceHistoryMessages } from './session-history.js';
 import {
   CLAUDE_ENV_KEYS,
   loadAgentEnvDoc,
@@ -1376,11 +1377,9 @@ export function createApp() {
       const { sessionId } = req.params;
       if (!/^[0-9a-f-]{36}$/i.test(sessionId)) return res.status(400).json({ error: 'Invalid session id' });
       const preferred = typeof req.query.agent === 'string' ? req.query.agent : null;
-      // tail=0 → full history (default). Positive = last N messages only.
-      let tail = parseInt(req.query.tail ?? '0', 10);
-      if (Number.isNaN(tail)) tail = 0;
-      if (tail < 0) tail = 0;
-      if (tail > 50_000) tail = 50_000;
+      // tail=0 → full history (default). Positive = last N. before = exclusive
+      // end index for older pages (scroll-up).
+      const { tail, before } = parseHistoryQuery(req.query);
       const compact = req.query.compact !== '0' && req.query.compact !== 'false';
       const opts = {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
@@ -1403,20 +1402,16 @@ export function createApp() {
       let messages = Array.isArray(bundle)
         ? bundle
         : (bundle.messages || []);
-      const total = messages.length;
-      let truncated = false;
-      if (tail > 0 && messages.length > tail) {
-        messages = messages.slice(-tail);
-        truncated = true;
-      }
-      if (compact) messages = compactHistoryMessages(messages);
+      const page = sliceHistoryMessages(messages, { tail, before });
+      messages = compact ? compactHistoryMessages(page.messages) : page.messages;
       const payload = {
         messages,
         context: Array.isArray(bundle) ? null : (bundle.context || null),
         agent: Array.isArray(bundle) ? (preferred || 'claude') : (bundle.agent || preferred || 'claude'),
-        total,
-        truncated,
-        tail: truncated ? tail : total,
+        total: page.total,
+        truncated: page.truncated,
+        oldestIndex: page.oldestIndex,
+        tail: page.tail,
         compact,
       };
       res.setHeader('X-Session-Agent', payload.agent);
@@ -1552,6 +1547,27 @@ export function createApp() {
     }
   });
 
+  app.get('/api/sessions/:sessionId/jsonl', authMiddleware, async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) {
+        return res.status(400).json({ error: 'Invalid session id' });
+      }
+      const agent = typeof req.query.agent === 'string' ? req.query.agent : null;
+      if (agent && !['claude', 'codex', 'grok', 'gemini', 'cursor'].includes(agent)) {
+        return res.status(400).json({ error: 'Invalid agent' });
+      }
+      const result = await loadSessionJsonl(sessionId, agent, {
+        claudeConfigDirs: CLAUDE_CONFIG_DIRS, codexHome: CODEX_HOME,
+        grokHome: GROK_HOME, geminiHome: GEMINI_HOME, cursorHome: CURSOR_HOME,
+      }, { offset: req.query.offset, maxLines: req.query.limit,
+        tail: req.query.tail === '1', maxChars: req.query.maxChars });
+      if (!result) return res.status(404).json({ error: 'Session JSONL not found' });
+      res.setHeader('Cache-Control', 'no-store');
+      res.json({ ...result, sessionId, running: isSessionBusy(sessionId) });
+    } 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;

package/src/session-history.js

@@ -0,0 +1,31 @@
+/** Slice a loaded transcript for mobile/hub transfers. */
+
+export function parseHistoryQuery(query = {}) {
+  let tail = parseInt(query.tail ?? '0', 10);
+  if (Number.isNaN(tail) || tail < 0) tail = 0;
+  if (tail > 50_000) tail = 50_000;
+  let before = parseInt(query.before ?? '', 10);
+  if (Number.isNaN(before) || before < 0) before = null;
+  return { tail, before };
+}
+
+/**
+ * @param {unknown[]} messages
+ * @param {{ tail?: number, before?: number|null }} opts
+ */
+export function sliceHistoryMessages(messages, { tail = 0, before = null } = {}) {
+  const all = Array.isArray(messages) ? messages : [];
+  const total = all.length;
+  let end = total;
+  if (before != null) end = Math.min(before, total);
+  if (end < 0) end = 0;
+  let start = 0;
+  if (tail > 0 && end - start > tail) start = end - tail;
+  return {
+    messages: all.slice(start, end),
+    total,
+    truncated: start > 0,
+    oldestIndex: start,
+    tail: end - start,
+  };
+}