claude-simple 0.2.25 → 0.2.27

package/src/agents/meta-agent.js

@@ -28,8 +28,8 @@ import crypto from 'crypto';
 import { spawn } from 'child_process';
 
 export const AI_DEFAULTS = {
-  url: 'https://api.deepseek.com/chat/completions',
-  model: 'deepseek-chat',
+  url: 'https://api.xiaomimimo.com/v1/chat/completions',
+  model: 'mimo-v2.5',
   vlm_url: '',
   vlm_model: '',
   temperature: 0.3,
@@ -51,7 +51,8 @@ export const DEFAULT_SYSTEM = `你是 Claude Simple UI 的内置工作助手（M
    - 同一批图的追问：传入上次返回的 thread_id + 新 prompt，可复用图片与历史问答，不必重复传路径（也可继续传 paths 以补图）。
    - 不要假装已经看到图片；没调用工具就说「根据路径无法看见内容」。
 6. 需要验证时：write_file 写代码 → run_command 执行 → 根据输出迭代。
-7. 回复简洁有结构，中文优先（用户用中文时）。`;
+7. 查找项目文件时优先用 find_files；先缩小范围再 read_file，不要用 run_command 代替只读检索。
+8. 回复简洁有结构，中文优先（用户用中文时）。`;
 
 export const REPORT_SYSTEM = `你是工作复盘助手。根据提供的 JSON 活动快照，写一份清晰的工作报告（Markdown）。
 结构建议：
@@ -292,6 +293,23 @@ const TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'find_files',
+      description: '按文件名在目录树中查找文件；适合先定位代码、配置或文档，再用 read_file 读取内容',
+      parameters: {
+        type: 'object',
+        required: ['path', 'query'],
+        properties: {
+          path: { type: 'string', description: '要搜索的根目录（绝对路径）' },
+          query: { type: 'string', description: '文件名关键词，不区分大小写' },
+          max: { type: 'integer', description: '最多返回条数，默认 80，上限 200' },
+          maxDepth: { type: 'integer', description: '最大目录深度，默认 5，上限 10' },
+        },
+      },
+    },
+  },
   {
     type: 'function',
     function: {
@@ -504,12 +522,16 @@ export function createMetaAgent(deps) {
     cursorHome,
   } = deps;
 
-  const configFile = path.join(rootDir, '.ai_config.json');
-  const reportsFile = path.join(rootDir, '.ai_reports.json');
-  const legacySessionsFile = path.join(rootDir, '.ai_sessions.json');
   const aiDir = process.env.AI_DATA_DIR
     ? expandPath(process.env.AI_DATA_DIR)
     : path.join(rootDir, '.ai');
+  // Keep credentials and reports outside an npm-installed package whenever
+  // AI_DATA_DIR is configured. Legacy files are read once for compatibility.
+  const configFile = path.join(aiDir, 'config.json');
+  const reportsFile = path.join(aiDir, 'reports.json');
+  const legacyConfigFile = path.join(rootDir, '.ai_config.json');
+  const legacyReportsFile = path.join(rootDir, '.ai_reports.json');
+  const legacySessionsFile = path.join(rootDir, '.ai_sessions.json');
   const notesFile = path.join(aiDir, 'meta-notes.json');
   const sessionBriefsFile = path.join(aiDir, 'session-briefs.json');
   const sessionsDir = path.join(aiDir, 'sessions');
@@ -1455,10 +1477,15 @@ export function createMetaAgent(deps) {
 
   async function loadConfig() {
     if (configCache) return configCache;
+    await ensureAiDirs();
     try {
       configCache = { ...AI_DEFAULTS, ...JSON.parse(await fs.readFile(configFile, 'utf8')) };
     } catch {
-      configCache = { ...AI_DEFAULTS, key: '', vlm_key: '', system: DEFAULT_SYSTEM };
+      try {
+        configCache = { ...AI_DEFAULTS, ...JSON.parse(await fs.readFile(legacyConfigFile, 'utf8')) };
+      } catch {
+        configCache = { ...AI_DEFAULTS, key: '', vlm_key: '', system: DEFAULT_SYSTEM };
+      }
     }
     if (!configCache.system) configCache.system = DEFAULT_SYSTEM;
     return configCache;
@@ -1492,10 +1519,15 @@ export function createMetaAgent(deps) {
 
   async function loadReports() {
     if (reportsCache) return reportsCache;
+    await ensureAiDirs();
     try {
       reportsCache = JSON.parse(await fs.readFile(reportsFile, 'utf8'));
     } catch {
-      reportsCache = {};
+      try {
+        reportsCache = JSON.parse(await fs.readFile(legacyReportsFile, 'utf8'));
+      } catch {
+        reportsCache = {};
+      }
     }
     return reportsCache;
   }
@@ -1622,11 +1654,26 @@ export function createMetaAgent(deps) {
     return res;
   }
 
+  function isMimoModel(model) {
+    return String(model || '').toLowerCase().includes('mimo');
+  }
+
+  function providerOptions(body) {
+    if (!isMimoModel(body?.model)) return body;
+    // `extra_body` is an SDK-only Python convenience. This server uses fetch,
+    // so MiMo's provider option must be sent at the JSON body top level.
+    return {
+      ...body,
+      max_completion_tokens: body.max_completion_tokens || 2048,
+      thinking: { type: 'disabled' },
+    };
+  }
+
   async function chatSync(cfg, body) {
     const res = await chatCompletions({
       url: cfg.url || AI_DEFAULTS.url,
       apiKey: cfg.key || '',
-      body: { ...body, stream: false },
+      body: providerOptions({ ...body, stream: false }),
     });
     return res.json();
   }
@@ -1635,7 +1682,7 @@ export function createMetaAgent(deps) {
     const res = await chatCompletions({
       url: cfg.url || AI_DEFAULTS.url,
       apiKey: cfg.key || '',
-      body: { ...body, stream: true },
+      body: providerOptions({ ...body, stream: true }),
     });
     const reader = res.body.getReader();
     const dec = new TextDecoder();
@@ -1821,6 +1868,37 @@ export function createMetaAgent(deps) {
           path: path.join(dir, e.name),
         }));
       }
+      case 'find_files': {
+        const root = expandPath(args.path);
+        if (!path.isAbsolute(root)) return { error: 'path must be absolute' };
+        const query = String(args.query || '').trim().toLowerCase();
+        if (!query) return { error: 'query required' };
+        const max = Math.min(Math.max(args.max || 80, 1), 200);
+        const maxDepth = Math.min(Math.max(args.maxDepth || 5, 0), 10);
+        const ignored = new Set(['.git', 'node_modules', 'dist', 'build', '.next', '.dart_tool']);
+        const matches = [];
+        async function visit(dir, depth) {
+          if (matches.length >= max || depth > maxDepth) return;
+          let entries;
+          try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+          } catch {
+            return;
+          }
+          for (const entry of entries) {
+            if (matches.length >= max) return;
+            if (ignored.has(entry.name) || entry.isSymbolicLink()) continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              await visit(full, depth + 1);
+            } else if (entry.isFile() && entry.name.toLowerCase().includes(query)) {
+              matches.push(full);
+            }
+          }
+        }
+        await visit(root, 0);
+        return { root, query, matches, truncated: matches.length >= max };
+      }
       case 'read_file': {
         const p = expandPath(args.path);
         const maxBytes = Math.min(args.maxBytes || 120000, 500000);
@@ -1989,7 +2067,7 @@ export function createMetaAgent(deps) {
           const res = await chatCompletions({
             url: vlmUrl,
             apiKey: vlmKey,
-            body: { ...body, stream: false },
+            body: providerOptions({ ...body, stream: false }),
           });
           const json = await res.json();
           const text = json.choices?.[0]?.message?.content || '';
@@ -2097,12 +2175,6 @@ export function createMetaAgent(deps) {
         stream: true,
         temperature: config.temperature ?? 0.3,
       };
-      // some providers
-      if (body.model && String(body.model).includes('mimo')) {
-        body.max_completion_tokens = 2048;
-        body.extra_body = { thinking: { type: 'disabled' } };
-      }
-
       await streamChat(config, body, (chunk) => {
         const d = chunk.choices?.[0]?.delta;
         if (d?.content) {

package/src/agents/sessions.js

@@ -217,6 +217,38 @@ export async function parseClaudeMessages(filePath) {
   return messages;
 }
 
+async function forkClaudeNativeSession(sourceSessionId, targetSessionId, claudeConfigDirs, assistantText, occurrence) {
+  const sourceFile = await findClaudeSessionFile(sourceSessionId, claudeConfigDirs);
+  if (!sourceFile) throw new Error('Claude source transcript was not found');
+
+  const source = await fs.readFile(sourceFile, 'utf8');
+  const output = [];
+  let foundForkPoint = false;
+  let seenMatches = 0;
+  for (const line of source.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let record;
+    try { record = JSON.parse(line); } catch { continue; }
+    output.push(JSON.stringify(replaceSessionId(record, sourceSessionId, targetSessionId)));
+    if (record.type !== 'assistant' || !Array.isArray(record.message?.content)) continue;
+    for (const part of record.message.content) {
+      if (part?.type === 'text' && part.text?.trim() === assistantText && ++seenMatches === occurrence) {
+        foundForkPoint = true;
+        break;
+      }
+    }
+    if (foundForkPoint) break;
+  }
+  if (!foundForkPoint) throw new Error('Selected Claude assistant message was not found in the native transcript');
+
+  const targetFile = path.join(path.dirname(sourceFile), `${targetSessionId}.jsonl`);
+  const tempFile = `${targetFile}.tmp-${crypto.randomUUID()}`;
+  await fs.writeFile(tempFile, `${output.join('\n')}\n`, 'utf8');
+  await fs.rename(tempFile, targetFile);
+  claudeFileCache.set(targetSessionId, targetFile);
+  return targetFile;
+}
+
 // ─── Codex ────────────────────────────────────────────────────────────────────
 
 async function loadCodexIndex(codexHome) {
@@ -407,6 +439,63 @@ export async function parseCodexMessages(filePath) {
   return messages;
 }
 
+function replaceSessionId(value, sourceSessionId, targetSessionId) {
+  if (value === sourceSessionId) return targetSessionId;
+  if (Array.isArray(value)) return value.map(item => replaceSessionId(item, sourceSessionId, targetSessionId));
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value)
+      .map(([key, item]) => [key, replaceSessionId(item, sourceSessionId, targetSessionId)]));
+  }
+  return value;
+}
+
+/**
+ * Codex can only resume a session from its native event log.  Re-serializing a
+ * chat transcript loses turn context, tool results, and injected instructions,
+ * so a fork must clone the native rollout and cut it at the selected answer.
+ */
+async function forkCodexNativeSession(sourceSessionId, targetSessionId, codexHome, assistantText, occurrence) {
+  const sourceFile = await findCodexSessionFile(sourceSessionId, codexHome);
+  if (!sourceFile) throw new Error('Codex source rollout was not found');
+
+  const source = await fs.readFile(sourceFile, 'utf8');
+  const output = [];
+  let foundForkPoint = false;
+  let seenMatches = 0;
+  for (const line of source.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let record;
+    try { record = JSON.parse(line); } catch { continue; }
+
+    output.push(JSON.stringify(replaceSessionId(record, sourceSessionId, targetSessionId)));
+    const payload = record.type === 'response_item' ? record.payload : null;
+    if (payload?.type !== 'message' || payload.role !== 'assistant') continue;
+    const text = (payload.content || [])
+      .filter(part => part?.type === 'output_text' || part?.type === 'text')
+      .map(part => part.text || '')
+      .join('\n')
+      .trim();
+    if (text === assistantText && ++seenMatches === occurrence) {
+      foundForkPoint = true;
+      break;
+    }
+  }
+  if (!foundForkPoint) {
+    throw new Error('Selected Codex assistant message was not found in the native rollout');
+  }
+
+  const now = new Date();
+  const day = now.toISOString().slice(0, 10).split('-');
+  const targetDir = path.join(codexHome, 'sessions', day[0], day[1], day[2]);
+  const fileStamp = now.toISOString().replace(/[:.]/g, '-').replace('Z', '');
+  const targetFile = path.join(targetDir, `rollout-${fileStamp}-${targetSessionId}.jsonl`);
+  await fs.mkdir(targetDir, { recursive: true });
+  const tempFile = `${targetFile}.tmp-${crypto.randomUUID()}`;
+  await fs.writeFile(tempFile, `${output.join('\n')}\n`, 'utf8');
+  await fs.rename(tempFile, targetFile);
+  return targetFile;
+}
+
 // ─── Grok ─────────────────────────────────────────────────────────────────────
 
 export async function scanGrokSessions(grokHome, filterCwd = null) {
@@ -1671,6 +1760,42 @@ export async function convertSession(sourceSessionId, sourceAgent, targetAgent,
   if (ta === 'gemini' || ta === 'cursor') {
     throw new Error(`${ta === 'cursor' ? 'Cursor' : 'Gemini'} sessions use native conversation storage and cannot be cloned safely. Start a new session instead.`);
   }
+
+  if (ta === 'claude' && sourceAgent.toLowerCase() === 'claude' && Number.isInteger(upTo)) {
+    const selected = messages[messages.length - 1];
+    if (selected?.role !== 'assistant' || !selected.content?.trim()) {
+      throw new Error('A Claude fork must end at a persisted assistant message');
+    }
+    const occurrence = messages.filter(message => message.role === 'assistant'
+      && message.content?.trim() === selected.content.trim()).length;
+    await forkClaudeNativeSession(sourceSessionId, targetSessionId, claudeConfigDirs, selected.content.trim(), occurrence);
+    try {
+      const configDir = claudeConfigDirs?.[0] || path.join(os.homedir(), '.claude');
+      await fs.appendFile(path.join(configDir, 'history.jsonl'), JSON.stringify({
+        display, pastedContents: {}, timestamp: Date.now(), project: cwd, sessionId: targetSessionId,
+      }) + '\n', 'utf8');
+    } catch {}
+    return { targetSessionId };
+  }
+
+  // A same-agent Codex fork must remain a native rollout.  The old synthetic
+  // serializer produced a visible transcript, but `codex exec resume` did not
+  // have the original turn context to continue it as an actual branch.
+  if (ta === 'codex' && sourceAgent.toLowerCase() === 'codex' && Number.isInteger(upTo)) {
+    const home = codexHome || path.join(os.homedir(), '.codex');
+    const selected = messages[messages.length - 1];
+    if (selected?.role !== 'assistant' || !selected.content?.trim()) {
+      throw new Error('A Codex fork must end at a persisted assistant message');
+    }
+    const occurrence = messages.filter(message => message.role === 'assistant'
+      && message.content?.trim() === selected.content.trim()).length;
+    await forkCodexNativeSession(sourceSessionId, targetSessionId, home, selected.content.trim(), occurrence);
+    try {
+      const indexFile = path.join(home, 'session_index.jsonl');
+      await fs.appendFile(indexFile, JSON.stringify({ id: targetSessionId, thread_name: display }) + '\n', 'utf8');
+    } catch {}
+    return { targetSessionId };
+  }
   
   if (ta === 'claude') {
     const configDir = claudeConfigDirs?.[0] || path.join(os.homedir(), '.claude');

package/src/app.js

@@ -142,15 +142,16 @@ let sessionMetaCache = null;
 
 /** Normalize project entry: old { notes } was the goal line. */
 function normalizeProjectEntry(entry) {
-  if (!entry || typeof entry !== 'object') return { goal: '', notes: '', updatedAt: 0 };
+  if (!entry || typeof entry !== 'object') return { goal: '', notes: '', hidden: false, updatedAt: 0 };
   const hasGoalKey = Object.prototype.hasOwnProperty.call(entry, 'goal');
   if (!hasGoalKey && entry.notes != null) {
     // legacy: single notes field = Project Goal
-    return { goal: String(entry.notes || ''), notes: '', updatedAt: entry.updatedAt || 0 };
+    return { goal: String(entry.notes || ''), notes: '', hidden: Boolean(entry.hidden), updatedAt: entry.updatedAt || 0 };
   }
   return {
     goal: String(entry.goal || ''),
     notes: String(entry.notes || ''),
+    hidden: Boolean(entry.hidden),
     updatedAt: entry.updatedAt || 0,
   };
 }
@@ -429,9 +430,9 @@ async function dispatchAgent(agent, command, options, send) {
   }
 }
 
-function abortSession(sessionId) {
+function abortSession(sessionId, { preserveQueue = false } = {}) {
   if (!sessionId) return false;
-  let ok = cancelGrokQueue(sessionId) > 0;
+  let ok = !preserveQueue && cancelGrokQueue(sessionId) > 0;
   cancelApprovalsForSession(sessionId);
   // Grok/Codex may register under temp key + real sessionId — abort every match.
   for (const [key, s] of activeSessions) {
@@ -522,6 +523,25 @@ export function createApp() {
   function liveRole(req) {
     return req.user?.role || 'viewer';
   }
+  function sessionResourceKey(sessionId, agent) {
+    return `session:${localMachineId()}:${agent || 'claude'}:${sessionId}`;
+  }
+  async function enforceSessionLock(req, res, sessionId, agent) {
+    if (!sessionId) return true;
+    const key = req.headers['x-lock-key'] || sessionResourceKey(sessionId, agent);
+    const r = await collab.requireLock({
+      key,
+      lockToken: req.headers['x-lock-token'],
+      writer: req.user.username,
+      writerRole: liveRole(req),
+    });
+    if (r.code !== 200) {
+      res.status(r.code).json({ error: r.error, lock: r.lock });
+      return false;
+    }
+    if (r.lock?.token) res.setHeader('X-Lock-Token', r.lock.token);
+    return true;
+  }
   function requireRole(need) {
     return (req, res, next) => {
       if (!roleAtLeast(liveRole(req), need)) {
@@ -815,20 +835,19 @@ export function createApp() {
     res.json(r.lock);
   });
 
-  app.post('/api/collab/lock-action', authMiddleware, async (req, res) => {
-    const key = decodeURIComponent(req.body?.key || '');
-    const action = req.body?.action;
+  async function handleLockAction(req, res, key, action, token, ttlSec) {
+    key = decodeURIComponent(key || '');
     if (action === 'heartbeat') {
       const r = await collab.heartbeat({
-        key, holder: req.user.username, lockToken: req.body?.token,
-        ttlMs: (req.body?.ttlSec || 60) * 1000,
+        key, holder: req.user.username, lockToken: token,
+        ttlMs: (ttlSec || 60) * 1000,
       });
       if (r.code !== 200) return res.status(r.code).json({ error: r.error });
       return res.json(r.lock);
     }
     if (action === 'release') {
       const r = await collab.release({
-        key, holder: req.user.username, lockToken: req.body?.token, force: false,
+        key, holder: req.user.username, lockToken: token, force: false,
       });
       if (r.code !== 200) return res.status(r.code).json({ error: r.error });
       return res.json({ ok: true });
@@ -839,6 +858,14 @@ export function createApp() {
       return res.json({ ok: true });
     }
     res.status(400).json({ error: 'unknown action' });
+  }
+
+  app.post('/api/collab/lock-action', authMiddleware, async (req, res) => {
+    await handleLockAction(req, res, req.body?.key, req.body?.action, req.body?.token, req.body?.ttlSec);
+  });
+
+  app.post('/api/collab/locks/:key/:action', authMiddleware, async (req, res) => {
+    await handleLockAction(req, res, req.params.key, req.params.action, req.body?.token, req.body?.ttlSec);
   });
 
   app.get('/api/collab/routes', authMiddleware, async (req, res) => {
@@ -1168,7 +1195,7 @@ export function createApp() {
 
   app.post('/api/projects/notes', authMiddleware, async (req, res) => {
     try {
-      const { root, goal, notes } = req.body || {};
+      const { root, goal, notes, hidden } = req.body || {};
       if (!root) return res.status(400).json({ error: 'root required' });
       const resolved = path.resolve(expandPath(root));
       const db = await loadProjectNotes();
@@ -1177,6 +1204,7 @@ export function createApp() {
       const next = {
         goal: goal !== undefined ? String(goal || '') : prev.goal,
         notes: notes !== undefined ? String(notes || '') : prev.notes,
+        hidden: hidden !== undefined ? Boolean(hidden) : prev.hidden,
         updatedAt: Date.now(),
       };
       db[resolved] = next;
@@ -1392,7 +1420,10 @@ export function createApp() {
         compact,
       };
       res.setHeader('X-Session-Agent', payload.agent);
-      res.setHeader('Cache-Control', 'private, max-age=30');
+      // A session can be appended while a turn is streaming. Returning a
+      // cached transcript here lets a client paint an old snapshot after a
+      // newer WS update, so session history must always be read fresh.
+      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
       res.json(payload);
     } catch (e) {
       res.status(500).json({ error: e.message });
@@ -1449,6 +1480,7 @@ export function createApp() {
       if (!ENABLED_AGENTS.includes(detectedSourceAgent)) {
         return res.status(400).json({ error: 'A valid sourceAgent is required' });
       }
+      if (!await enforceSessionLock(req, res, sessionId, detectedSourceAgent)) return;
       const opts = {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
@@ -1913,6 +1945,9 @@ export function createApp() {
       ws,
       sessionId: url.searchParams.get('sessionId') || null,
       agent: url.searchParams.get('agent') || null,
+      username: decoded.username || null,
+      role: decoded.role || (decoded.viaHub ? 'editor' : 'editor'),
+      viaHub: !!decoded.viaHub,
       externalMirrorKey: null,
     };
     chatClients.add(client);
@@ -2003,7 +2038,7 @@ export function createApp() {
 
       if (cmd.cmd === 'turn.interrupt') {
         const sid = cmd.sessionId;
-        const ok = abortSession(sid);
+        const ok = abortSession(sid, { preserveQueue: cmd.preserveQueue === true });
         wireSend({ type: 'abort-result', success: ok, sessionId: sid });
         wireSend({ type: 'grok-queue-status', agent: 'grok', sessionId: sid, running: false, items: [] });
         outbox.flush();
@@ -2016,6 +2051,24 @@ export function createApp() {
         if (cmd.sessionId) options.sessionId = cmd.sessionId;
         if (cmd.cwd) options.cwd = cmd.cwd;
         if (options.sessionId) client.sessionId = options.sessionId;
+        // Hub already enforced the lease (X-Hub-User). Standalone checks here.
+        if (!client.viaHub && options.sessionId && client.username) {
+          const lockTok = cmd.lockToken || options.lockToken || msg.lockToken;
+          const r = await collab.requireLock({
+            key: sessionResourceKey(options.sessionId, agent),
+            lockToken: lockTok,
+            writer: client.username,
+            writerRole: client.role || 'editor',
+          });
+          if (r.code !== 200) {
+            wireSend({
+              type: 'error', code: r.code, message: r.error || 'locked',
+              lock: r.lock, sessionId: options.sessionId,
+            });
+            outbox.flush();
+            return;
+          }
+        }
         // 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.
@@ -2048,11 +2101,9 @@ export function createApp() {
         } finally {
           // `complete` is a UI-facing agent event and is not a reliable
           // scheduling boundary (an adapter may emit it early or more than
-          // once). The hub advances its Grok FIFO only after dispatchAgent has
-          // actually returned from the ACP request.
-          if (agent === 'grok') {
-            runOutbox.send({ type: 'hub-turn-finished', agent, sessionId: runSessionId });
-          }
+          // once). Clients may only advance a local FIFO after the adapter has
+          // actually returned and released the session, for every agent.
+          runOutbox.send({ type: 'hub-turn-finished', agent, sessionId: runSessionId });
           runOutbox.flush();
         }
         return;