claude-simple 0.2.5 → 0.2.7

package/public/terminal.js

@@ -11,6 +11,37 @@ let lastMachine = null;
 let shellGen = 0;
 let shellReconnectTimer = null;
 let shellWanted = false;
+let terminalEventsBound = false;
+const mobileKeyData = {
+  'ctrl-c': '\x03', escape: '\x1b', tab: '\t',
+  up: '\x1b[A', down: '\x1b[B', left: '\x1b[D', right: '\x1b[C'
+};
+
+function sendInput(data) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: 'input', data }));
+  }
+}
+
+function isMobileShell() {
+  return window.matchMedia('(max-width: 640px), (hover: none) and (pointer: coarse)').matches;
+}
+
+/** Mobile IMEs do not reliably drive xterm's off-screen textarea. Use a real
+ * input there so composition, prediction and paste remain visible and intact. */
+function focusTerminal() {
+  if (isMobileShell()) {
+    document.getElementById('term-mobile-input')?.focus({ preventScroll: true });
+    return;
+  }
+  term?.focus();
+  const input = document.querySelector('#terminal-container .xterm-helper-textarea');
+  if (input) {
+    input.focus({ preventScroll: true });
+    // iOS may ignore the first focus while its visual viewport is settling.
+    requestAnimationFrame(() => input.focus({ preventScroll: true }));
+  }
+}
 
 function initXterm() {
   if (term) return;
@@ -59,15 +90,35 @@ function initXterm() {
   fitTerminal();
 
   term.onData(data => {
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: 'input', data }));
-    }
+    sendInput(data);
   });
 
+  // On phones this focuses the native command input; desktop keeps xterm's
+  // direct keyboard interaction.
+  container.addEventListener('pointerdown', () => focusTerminal(), { passive: true });
+  container.addEventListener('touchend', () => focusTerminal(), { passive: true });
+
   window.addEventListener('resize', () => {
     fitTerminal();
     sendResize();
   });
+
+  const vv = window.visualViewport;
+  if (vv) {
+    let raf = 0;
+    const fitForVisualViewport = () => {
+      if (raf) cancelAnimationFrame(raf);
+      raf = requestAnimationFrame(() => {
+        raf = 0;
+        if (currentTab.peek() === 'shell') {
+          fitTerminal();
+          sendResize();
+        }
+      });
+    };
+    vv.addEventListener('resize', fitForVisualViewport);
+    vv.addEventListener('scroll', fitForVisualViewport);
+  }
 }
 
 function fitTerminal() {
@@ -177,6 +228,29 @@ function activateShellTab() {
 }
 
 export function initTerminal() {
+  if (!terminalEventsBound) {
+    terminalEventsBound = true;
+    document.getElementById('term-keyboard')?.addEventListener('click', focusTerminal);
+    document.getElementById('term-mobile-composer')?.addEventListener('submit', event => {
+      event.preventDefault();
+      const input = document.getElementById('term-mobile-input');
+      if (!input) return;
+      sendInput(`${input.value}\r`);
+      input.value = '';
+      input.focus({ preventScroll: true });
+    });
+    document.getElementById('term-mobile-keys')?.addEventListener('pointerdown', event => {
+      // Keep the native command input focused while using the touch shortcut row.
+      if (event.target.closest('[data-term-key]')) event.preventDefault();
+    });
+    document.getElementById('term-mobile-keys')?.addEventListener('click', event => {
+      const key = event.target.closest('[data-term-key]')?.dataset.termKey;
+      if (!key || !mobileKeyData[key]) return;
+      sendInput(mobileKeyData[key]);
+      focusTerminal();
+    });
+  }
+
   document.addEventListener('visibilitychange', () => {
     if (document.visibilityState !== 'visible') return;
     if (currentTab.peek() !== 'shell' || !shellWanted) return;

package/src/agents/claude.js

@@ -23,7 +23,7 @@ export async function runClaude(command, options, send, { cliPath, activeSession
   const env = { ...process.env };
   if (options.configDir) env.CLAUDE_CONFIG_DIR = options.configDir;
 
-  const permissionMode = options.permissionMode || 'default';
+  const permissionMode = options.permissionMode || 'bypassPermissions';
   const autoApprove = permissionMode === 'bypassPermissions'
     || permissionMode === 'acceptEdits'
     || permissionMode === 'auto'

package/src/agents/codex.js

@@ -12,6 +12,7 @@ import crypto from 'crypto';
  */
 
 function mapPermissionToMode(permissionMode) {
+  if (permissionMode == null) return 'yolo';
   switch (permissionMode) {
     case 'acceptEdits':
     case 'auto':

package/src/agents/grok.js

@@ -22,8 +22,9 @@ import { createDeltaBatcher } from './stream-batch.js';
 
 function mapPermission(permissionMode, allowBypass) {
   if (allowBypass || permissionMode === 'bypassPermissions') return 'bypassPermissions';
-  if (permissionMode && permissionMode !== 'default') return permissionMode;
-  return null;
+  if (permissionMode == null) return 'bypassPermissions';
+  if (permissionMode === 'default') return null;
+  return permissionMode;
 }
 
 function buildArgs(command, options) {

package/src/agents/meta-agent.js

@@ -41,7 +41,7 @@ export const AI_DEFAULTS = {
 export const DEFAULT_SYSTEM = `你是 Claude Simple UI 的内置工作助手（Meta Agent）。你能访问本机上的 Claude / Codex / Grok 会话、项目笔记、Git 与文件，并生成「我做了啥」的工作报告。
 
 规则：
-1. 需要会话 id / 项目路径时，先 list_projects 或 search_activity / list_sessions，再深入 get_session_summary。
+1. 需要会话 id / 项目路径时，先 list_projects 或 search_activity / list_sessions，再深入 get_session_brief / get_session_summary。超长会话先读 get_session_brief；只有需要逐事件定位问题时才读 get_session_jsonl。
 2. 回答要具体：引用项目路径、会话标题、时间范围；不确定就再查。
 3. 写日报/周报用 generate_activity_digest 拉快照，再组织成清晰 Markdown（亮点、按项目、未完成、建议）。
 4. 改文件或跑命令前说明意图；危险命令拒绝（rm -rf /、格式化磁盘等）。
@@ -133,6 +133,39 @@ const TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'get_session_brief',
+      description: '读取会话压缩上下文，适合非常长的 session；包含项目/会话备注、关键用户意图与最近进展',
+      parameters: {
+        type: 'object',
+        required: ['sessionId'],
+        properties: {
+          sessionId: { type: 'string' },
+          agent: { type: 'string' },
+          maxTurns: { type: 'integer', description: '默认 6，返回多少个采样转折点' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_session_jsonl',
+      description: '读取 Claude/Codex/Grok 指定会话的原始 JSONL 行，用于逐事件、工具调用或失败原因分析；内容可能敏感，只在当前回答中使用',
+      parameters: {
+        type: 'object',
+        required: ['sessionId'],
+        properties: {
+          sessionId: { type: 'string' },
+          agent: { type: 'string', enum: ['claude', 'codex', 'grok'], description: '建议明确指定来源 agent' },
+          offset: { type: 'integer', description: '从第几行开始，默认 0' },
+          maxLines: { type: 'integer', description: '每次最多 2000 行，默认 500' },
+        },
+      },
+    },
+  },
   {
     type: 'function',
     function: {
@@ -161,6 +194,62 @@ const TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'list_meta_notes',
+      description: '列出 Meta Notes（Hub 侧持久化工作笔记）',
+      parameters: {
+        type: 'object',
+        properties: {
+          scope: { type: 'string', enum: ['all', 'project', 'session', 'general'], description: '默认 all' },
+          q: { type: 'string', description: '按标题/正文搜索' },
+          cwd: { type: 'string', description: '按项目路径过滤' },
+          sessionId: { type: 'string', description: '按 session 过滤' },
+          agent: { type: 'string', description: 'session 过滤时可指定 agent' },
+          limit: { type: 'integer', description: '默认 30' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'save_meta_note',
+      description: '创建或更新一条 Meta Note，可关联项目或 session',
+      parameters: {
+        type: 'object',
+        required: ['title', 'content'],
+        properties: {
+          id: { type: 'string' },
+          title: { type: 'string' },
+          content: { type: 'string' },
+          cwd: { type: 'string' },
+          sessionId: { type: 'string' },
+          agent: { type: 'string' },
+          pinned: { type: 'boolean' },
+          tags: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'delete_meta_note',
+      description: '删除一条 Meta Note',
+      parameters: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+          id: { type: 'string' },
+        },
+      },
+    },
+  },
   {
     type: 'function',
     function: {
@@ -399,10 +488,12 @@ export function createMetaAgent(deps) {
     listSessions,
     searchActivity,
     loadSessionMessages,
+    loadSessionJsonl,
     groupByProject,
     toClientSession,
     getProjectNotesStore,
     saveProjectNotesStore,
+    getSessionMetaStore,
     normalizeProjectEntry,
     git,
     isGitRepo,
@@ -417,6 +508,8 @@ export function createMetaAgent(deps) {
   const aiDir = process.env.AI_DATA_DIR
     ? expandPath(process.env.AI_DATA_DIR)
     : path.join(rootDir, '.ai');
+  const notesFile = path.join(aiDir, 'meta-notes.json');
+  const sessionBriefsFile = path.join(aiDir, 'session-briefs.json');
   const sessionsDir = path.join(aiDir, 'sessions');
   /** @deprecated global vlm — only for one-time migration */
   const legacyGlobalVlmDir = path.join(aiDir, 'vlm');
@@ -461,6 +554,8 @@ export function createMetaAgent(deps) {
 
   let configCache = null;
   let reportsCache = null;
+  let notesCache = null;
+  let sessionBriefsCache = null;
   /** @type {{ version: number, sessions: Array<{id,title,createdAt,updatedAt,messageCount}> } | null} */
   let sessionsIndexCache = null;
   /** in-memory cache of full sessions (id → session) */
@@ -477,6 +572,42 @@ export function createMetaAgent(deps) {
     await fs.mkdir(sessionsDir, { recursive: true });
   }
 
+  async function loadNotesStore() {
+    if (notesCache) return notesCache;
+    await ensureAiDirs();
+    try {
+      const raw = JSON.parse(await fs.readFile(notesFile, 'utf8'));
+      notesCache = {
+        version: raw.version || 1,
+        notes: Array.isArray(raw.notes) ? raw.notes : [],
+      };
+    } catch {
+      notesCache = { version: 1, notes: [] };
+    }
+    return notesCache;
+  }
+
+  async function saveNotesStore() {
+    if (!notesCache) return;
+    await atomicWriteJson(notesFile, notesCache);
+  }
+
+  async function loadSessionBriefsStore() {
+    if (sessionBriefsCache) return sessionBriefsCache;
+    await ensureAiDirs();
+    try {
+      sessionBriefsCache = JSON.parse(await fs.readFile(sessionBriefsFile, 'utf8'));
+    } catch {
+      sessionBriefsCache = {};
+    }
+    return sessionBriefsCache;
+  }
+
+  async function saveSessionBriefsStore() {
+    if (!sessionBriefsCache) return;
+    await atomicWriteJson(sessionBriefsFile, sessionBriefsCache);
+  }
+
   async function atomicWriteText(filePath, text) {
     await fs.mkdir(path.dirname(filePath), { recursive: true });
     const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
@@ -918,6 +1049,178 @@ export function createMetaAgent(deps) {
     return '';
   }
 
+  function extractRoleText(message) {
+    if (!message) return '';
+    const text = extractTextParts(message.content ?? message.message?.content ?? message.text);
+    return String(text || '').replace(/\s+/g, ' ').trim();
+  }
+
+  function pickSample(items, count) {
+    if (!Array.isArray(items) || !items.length) return [];
+    if (items.length <= count) return items.slice();
+    const out = [];
+    const last = items.length - 1;
+    for (let i = 0; i < count; i += 1) {
+      const idx = Math.round((i * last) / Math.max(1, count - 1));
+      out.push(items[idx]);
+    }
+    return out.filter((item, i, arr) => i === arr.findIndex((x) => x === item));
+  }
+
+  async function listMetaNotes(query = {}) {
+    const store = await loadNotesStore();
+    const scope = query.scope || 'all';
+    const q = String(query.q || '').trim().toLowerCase();
+    const cwd = query.cwd ? expandPath(query.cwd) : '';
+    const sessionId = String(query.sessionId || '').trim();
+    const agent = String(query.agent || '').trim();
+    const limit = Math.min(query.limit || 30, 200);
+    let rows = [...store.notes];
+    if (scope !== 'all') rows = rows.filter((n) => n.scope === scope);
+    if (cwd) rows = rows.filter((n) => n.cwd === cwd);
+    if (sessionId) rows = rows.filter((n) => n.sessionId === sessionId);
+    if (agent) rows = rows.filter((n) => n.agent === agent);
+    if (q) {
+      rows = rows.filter((n) => `${n.title || ''}\n${n.content || ''}\n${(n.tags || []).join(' ')}`.toLowerCase().includes(q));
+    }
+    rows.sort((a, b) => {
+      if (!!b.pinned !== !!a.pinned) return Number(b.pinned) - Number(a.pinned);
+      return (b.updatedAt || 0) - (a.updatedAt || 0);
+    });
+    return rows.slice(0, limit);
+  }
+
+  async function getMetaNote(id) {
+    if (!id) return null;
+    const store = await loadNotesStore();
+    return store.notes.find((n) => n.id === id) || null;
+  }
+
+  async function saveMetaNote(input = {}) {
+    const store = await loadNotesStore();
+    const now = Date.now();
+    const id = input.id ? String(input.id) : crypto.randomUUID();
+    const cwd = input.cwd ? expandPath(input.cwd) : '';
+    const sessionId = String(input.sessionId || '').trim();
+    const agent = String(input.agent || '').trim() || (sessionId ? 'claude' : '');
+    const scope = sessionId ? 'session' : cwd ? 'project' : 'general';
+    const tags = Array.isArray(input.tags)
+      ? [...new Set(input.tags.map((x) => String(x || '').trim()).filter(Boolean))].slice(0, 12)
+      : [];
+    const prev = store.notes.find((n) => n.id === id);
+    const note = {
+      id,
+      scope,
+      title: String(input.title || '').trim().slice(0, 200),
+      content: String(input.content || '').trim(),
+      cwd,
+      sessionId,
+      agent,
+      pinned: Boolean(input.pinned),
+      tags,
+      createdAt: prev?.createdAt || now,
+      updatedAt: now,
+    };
+    if (!note.title) throw new Error('title required');
+    if (!note.content) throw new Error('content required');
+    if (prev) {
+      const idx = store.notes.findIndex((n) => n.id === id);
+      store.notes[idx] = note;
+    } else {
+      store.notes.unshift(note);
+    }
+    await saveNotesStore();
+    return note;
+  }
+
+  async function deleteMetaNote(id) {
+    if (!id) return { ok: false };
+    const store = await loadNotesStore();
+    const next = store.notes.filter((n) => n.id !== id);
+    const changed = next.length !== store.notes.length;
+    store.notes = next;
+    if (changed) await saveNotesStore();
+    return { ok: changed };
+  }
+
+  async function getSessionMetaNote(sessionId, agent) {
+    if (!sessionId || !getSessionMetaStore) return null;
+    const db = await getSessionMetaStore();
+    const key = `${agent || 'claude'}:${sessionId}`;
+    return db?.[key] || null;
+  }
+
+  async function findSessionRecord(sessionId, preferredAgent = null) {
+    const sessions = await listSessions(null, preferredAgent || null);
+    let hit = sessions.find((s) => s.sessionId === sessionId && (!preferredAgent || s.agent === preferredAgent));
+    if (!hit && !preferredAgent) hit = sessions.find((s) => s.sessionId === sessionId);
+    return hit || null;
+  }
+
+  async function buildSessionBrief(args = {}) {
+    const sessionId = args.sessionId || args.id;
+    if (!sessionId) return { error: 'sessionId required' };
+    const maxTurns = Math.min(args.maxTurns || 6, 12);
+    const record = await findSessionRecord(sessionId, args.agent || null);
+    const resolvedAgent = record?.agent || args.agent || null;
+    const updatedAt = record?.updatedAt || 0;
+    const cacheKey = `${resolvedAgent || '*'}:${sessionId}`;
+    const cache = await loadSessionBriefsStore();
+    const cached = cache[cacheKey];
+    if (cached && cached.updatedAt === updatedAt && cached.maxTurns === maxTurns) return cached.brief;
+
+    const bundle = await loadSessionMessages(sessionId, resolvedAgent, sessionOpts());
+    if (!bundle) return { error: 'session not found' };
+    const msgs = Array.isArray(bundle) ? bundle : (bundle.messages || []);
+    const userTurns = [];
+    const assistantTurns = [];
+    for (const m of msgs) {
+      const role = m.role || m.type;
+      if (role !== 'user' && role !== 'assistant') continue;
+      const text = extractRoleText(m);
+      if (!text || text.startsWith('Caveat:') || text.startsWith('<command-')) continue;
+      const row = { role, text: shortTitle(text, role === 'user' ? 260 : 220) };
+      if (role === 'user') userTurns.push(row);
+      else assistantTurns.push(row);
+    }
+    const checkpoints = pickSample(userTurns, maxTurns).map((turn, idx) => ({
+      index: idx + 1,
+      prompt: turn.text,
+    }));
+    const cwd = record?.cwd || null;
+    const projectNotesStore = cwd ? await getProjectNotesStore() : null;
+    const projectNotes = cwd ? normalizeProjectEntry(projectNotesStore?.[cwd] || {}) : { goal: '', notes: '' };
+    const sessionMeta = await getSessionMetaNote(sessionId, resolvedAgent || 'claude');
+    const linkedNotes = await listMetaNotes({ scope: 'session', sessionId, agent: resolvedAgent || undefined, limit: 8 });
+    const brief = {
+      sessionId,
+      agent: Array.isArray(bundle) ? resolvedAgent : (bundle.agent || resolvedAgent),
+      cwd,
+      projectName: record?.projectName || (cwd ? path.basename(cwd) : ''),
+      title: shortTitle(record?.display || record?.title || sessionId, 120),
+      updatedAt,
+      totalMessages: msgs.length,
+      userTurnCount: userTurns.length,
+      assistantTurnCount: assistantTurns.length,
+      firstUserPrompt: userTurns[0]?.text || '',
+      latestUserPrompt: userTurns[userTurns.length - 1]?.text || '',
+      latestAssistantReply: assistantTurns[assistantTurns.length - 1]?.text || '',
+      checkpoints,
+      projectGoal: projectNotes.goal || '',
+      projectNotes: projectNotes.notes ? shortTitle(projectNotes.notes, 300) : '',
+      sessionNote: (sessionMeta?.notes || '').trim(),
+      linkedNotes: linkedNotes.map((n) => ({
+        id: n.id,
+        title: n.title,
+        content: shortTitle(n.content, 240),
+        updatedAt: n.updatedAt,
+      })),
+    };
+    cache[cacheKey] = { updatedAt, maxTurns, brief, cachedAt: Date.now() };
+    await saveSessionBriefsStore();
+    return brief;
+  }
+
   function indexEntryFromSession(s) {
     return {
       id: s.id,
@@ -1441,6 +1744,20 @@ export function createMetaAgent(deps) {
           messages: summary,
         };
       }
+      case 'get_session_brief': {
+        return buildSessionBrief(args);
+      }
+      case 'get_session_jsonl': {
+        const sid = args.sessionId || args.id;
+        if (!sid) return { error: 'sessionId required' };
+        if (!loadSessionJsonl) return { error: 'raw session reader unavailable' };
+        const result = await loadSessionJsonl(sid, args.agent || null, sessionOpts(), {
+          offset: args.offset,
+          maxLines: args.maxLines,
+        });
+        if (!result) return { error: 'session JSONL not found' };
+        return result;
+      }
       case 'get_project_notes': {
         const store = await getProjectNotesStore();
         const cwd = expandPath(args.cwd);
@@ -1457,6 +1774,15 @@ export function createMetaAgent(deps) {
         await saveProjectNotesStore();
         return { ok: true, cwd, ...cur };
       }
+      case 'list_meta_notes': {
+        return listMetaNotes(args);
+      }
+      case 'save_meta_note': {
+        return saveMetaNote(args);
+      }
+      case 'delete_meta_note': {
+        return deleteMetaNote(args.id);
+      }
       case 'git_status': {
         const cwd = expandPath(args.cwd);
         if (!(await isGitRepo(cwd))) return { isGit: false };
@@ -1975,6 +2301,11 @@ export function createMetaAgent(deps) {
         .slice(0, limit);
     },
     buildDigest,
+    listMetaNotes,
+    getMetaNote,
+    saveMetaNote,
+    deleteMetaNote,
+    buildSessionBrief,
     executeTool,
     runLoop,
     resolveApproval,