claude-simple 0.2.24 → 0.2.26

package/src/agent-env.js

@@ -0,0 +1,211 @@
+/**
+ * Allowlisted env for Claude Code (and Anthropic-compatible gateways
+ * such as DeepSeek). LaunchAgents do not inherit shell exports, so we
+ * persist a profile and merge ~/.claude/settings.json `env` at spawn time.
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+export const CLAUDE_ENV_KEYS = [
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_API_KEY',
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'CLAUDE_CODE_SUBAGENT_MODEL',
+  'CLAUDE_CODE_EFFORT_LEVEL',
+  'CLAUDE_MODEL',
+  'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
+  'API_TIMEOUT_MS',
+  'ANTHROPIC_BETAS',
+];
+
+const SECRET_RE = /TOKEN|KEY|SECRET|PASSWORD/i;
+
+export function isSecretEnvKey(key) {
+  return SECRET_RE.test(key);
+}
+
+export function pickAllowedEnv(src) {
+  const out = {};
+  if (!src || typeof src !== 'object') return out;
+  for (const key of CLAUDE_ENV_KEYS) {
+    const v = src[key];
+    if (typeof v === 'string' && v.trim()) out[key] = v.trim();
+  }
+  return out;
+}
+
+export function mergeClaudeEnv(...layers) {
+  const out = {};
+  for (const layer of layers) {
+    if (!layer) continue;
+    Object.assign(out, pickAllowedEnv(layer));
+  }
+  return out;
+}
+
+/** Apply allowlisted keys onto a full process.env clone. */
+export function withClaudeEnv(processEnv, extra) {
+  return { ...processEnv, ...pickAllowedEnv(extra) };
+}
+
+const PLACEHOLDER_MODELS = new Set([
+  'default', 'auto', '', 'claude-sonnet-4-5', 'claude-sonnet-4-6',
+]);
+
+export function resolveClaudeModel(options, env) {
+  const requested = typeof options?.model === 'string' ? options.model.trim() : '';
+  const fromEnv = env?.ANTHROPIC_MODEL || env?.CLAUDE_MODEL || '';
+  const customGateway = !!(env?.ANTHROPIC_BASE_URL);
+  if (!requested || requested === 'default' || requested === 'auto') {
+    return fromEnv || undefined;
+  }
+  // Official fallback ids against a third-party Anthropic-compatible URL
+  // (DeepSeek etc.) would 404; prefer the env model.
+  if (customGateway && fromEnv && PLACEHOLDER_MODELS.has(requested)) {
+    return fromEnv;
+  }
+  return requested;
+}
+
+export function resolveClaudeEffort(options, env) {
+  const requested = typeof options?.effort === 'string' ? options.effort.trim() : '';
+  if (requested) return requested;
+  const fromEnv = env?.CLAUDE_CODE_EFFORT_LEVEL;
+  return fromEnv || undefined;
+}
+
+export function redactEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env || {})) {
+    if (isSecretEnvKey(k)) out[k] = { set: true, preview: maskSecret(v) };
+    else out[k] = v;
+  }
+  return out;
+}
+
+function maskSecret(v) {
+  const s = String(v);
+  if (s.length <= 8) return '••••';
+  return `${s.slice(0, 3)}…${s.slice(-4)}`;
+}
+
+export async function readSettingsJsonEnv(configDir) {
+  if (!configDir) return {};
+  const dir = String(configDir).replace(/^~/, os.homedir());
+  let acc = {};
+  for (const name of ['settings.json', 'settings.local.json']) {
+    try {
+      const raw = JSON.parse(await fs.readFile(path.join(dir, name), 'utf8'));
+      if (raw?.env && typeof raw.env === 'object') {
+        acc = { ...acc, ...pickAllowedEnv(raw.env) };
+      }
+    } catch { /* missing is fine */ }
+  }
+  return acc;
+}
+
+export function defaultAgentEnvPath() {
+  if (process.env.AGENT_ENV_FILE) return process.env.AGENT_ENV_FILE;
+  return path.join(os.homedir(), '.claude-simple-edge', 'agent-env.json');
+}
+
+export function normalizeProfileName(name) {
+  return String(name || '').trim();
+}
+
+export function parseAgentEnvDoc(raw) {
+  if (!raw || typeof raw !== 'object') return { env: {}, profiles: {} };
+  const hasProfiles = raw.profiles && typeof raw.profiles === 'object';
+  const env = pickAllowedEnv(raw.env || (!hasProfiles ? raw : {}));
+  const profiles = {};
+  if (hasProfiles) {
+    for (const [k, v] of Object.entries(raw.profiles)) {
+      const n = normalizeProfileName(k);
+      if (n) profiles[n] = pickAllowedEnv(v);
+    }
+  }
+  return { env, profiles };
+}
+
+export async function loadAgentEnvDoc(filePath = defaultAgentEnvPath()) {
+  try {
+    const raw = JSON.parse(await fs.readFile(filePath, 'utf8'));
+    return parseAgentEnvDoc(raw);
+  } catch {
+    return { env: {}, profiles: {} };
+  }
+}
+
+export async function saveAgentEnvDoc(doc, filePath = defaultAgentEnvPath()) {
+  const env = pickAllowedEnv(doc?.env);
+  const profiles = {};
+  for (const [k, v] of Object.entries(doc?.profiles || {})) {
+    const n = normalizeProfileName(k);
+    const picked = pickAllowedEnv(v);
+    if (n && Object.keys(picked).length) profiles[n] = picked;
+  }
+  await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const tmp = `${filePath}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify({ env, profiles }, null, 2), { mode: 0o600 });
+  await fs.rename(tmp, filePath);
+  return { env, profiles };
+}
+
+/** Default (unnamed) allowlist. Named profiles live under `profiles`. */
+export async function loadAgentEnvFile(filePath = defaultAgentEnvPath()) {
+  return (await loadAgentEnvDoc(filePath)).env;
+}
+
+export async function saveAgentEnvFile(env, filePath = defaultAgentEnvPath()) {
+  const doc = await loadAgentEnvDoc(filePath);
+  doc.env = pickAllowedEnv(env);
+  await saveAgentEnvDoc(doc, filePath);
+  return doc.env;
+}
+
+/** Default layer, then workspace-named profile (same name as Settings workspace). */
+export function envForProfile(doc, name) {
+  const n = normalizeProfileName(name);
+  const named = n && doc?.profiles?.[n] ? doc.profiles[n] : {};
+  return mergeClaudeEnv(doc?.env, named);
+}
+
+/** Merge incoming PATCH: omit key to keep, empty string to delete, string to set. */
+export function patchEnv(current, patch) {
+  const out = { ...pickAllowedEnv(current) };
+  if (!patch || typeof patch !== 'object') return out;
+  for (const key of CLAUDE_ENV_KEYS) {
+    if (!(key in patch)) continue;
+    const v = patch[key];
+    if (v == null || v === '' || (typeof v === 'object' && v.set === true && !v.value)) {
+      if (v && typeof v === 'object' && v.set === true) continue; // keep secret
+      delete out[key];
+      continue;
+    }
+    if (typeof v === 'string') out[key] = v.trim();
+    else if (typeof v === 'object' && typeof v.value === 'string') out[key] = v.value.trim();
+  }
+  return out;
+}
+
+export async function applyAgentEnvToProcess(processEnv = process.env) {
+  const fileEnv = await loadAgentEnvFile();
+  const settingsEnv = await readSettingsJsonEnv(path.join(os.homedir(), '.claude'));
+  const merged = mergeClaudeEnv(processEnv, settingsEnv, fileEnv);
+  for (const [k, v] of Object.entries(merged)) processEnv[k] = v;
+  return merged;
+}
+
+export async function buildClaudeSpawnEnv({ processEnv = process.env, configDir, extra, profile } = {}) {
+  const settingsEnv = await readSettingsJsonEnv(configDir || path.join(os.homedir(), '.claude'));
+  const doc = await loadAgentEnvDoc();
+  const fileEnv = envForProfile(doc, profile);
+  const allow = mergeClaudeEnv(processEnv, settingsEnv, fileEnv, extra);
+  return { ...processEnv, ...allow };
+}

package/src/agents/claude.js

@@ -2,6 +2,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import crypto from 'crypto';
 import { mapAgentEmit, compactToolInput } from '../runtime/protocol.js';
 import { waitForApproval, cancelApprovalsForSession } from '../runtime/approvals.js';
+import { buildClaudeSpawnEnv, resolveClaudeModel, resolveClaudeEffort } from '../agent-env.js';
 
 /**
  * Run a Claude Code turn via the agent SDK.
@@ -20,7 +21,11 @@ export async function runClaude(command, options, send, { cliPath, activeSession
     sessionId: options.sessionId || null,
   });
 
-  const env = { ...process.env };
+  const env = await buildClaudeSpawnEnv({
+    processEnv: process.env,
+    configDir: options.configDir,
+    profile: options.workspaceName || options.profile,
+  });
   if (options.configDir) env.CLAUDE_CONFIG_DIR = options.configDir;
 
   const permissionMode = options.permissionMode || 'bypassPermissions';
@@ -40,12 +45,14 @@ export async function runClaude(command, options, send, { cliPath, activeSession
     tools: { type: 'preset', preset: 'claude_code' },
     systemPrompt: { type: 'preset', preset: 'claude_code' },
     settingSources: ['project', 'user', 'local'],
-    model: options.model || 'claude-sonnet-4-5',
     abortSignal: controller.signal,
   };
+  const model = resolveClaudeModel(options, env);
+  if (model) sdkOptions.model = model;
+  const effort = resolveClaudeEffort(options, env);
+  if (effort) sdkOptions.effort = effort;
   if (options.cwd) sdkOptions.cwd = options.cwd;
   if (options.sessionId) sdkOptions.resume = options.sessionId;
-  if (options.effort) sdkOptions.effort = options.effort;
   if (permissionMode && permissionMode !== 'default') {
     sdkOptions.permissionMode = permissionMode;
   }

package/src/agents/grok.js

@@ -10,6 +10,30 @@ const clients = new Map();
 const queues = new Map();
 const queueAliases = new Map();
 
+/** Read-only queue snapshot used when a browser reconnects mid-turn. The ACP
+ * process owns the real queue; exposing it lets the UI restore the user's
+ * already-accepted follow-up prompts after a page refresh. */
+export function getGrokQueueState(sessionId) {
+  const key = (sessionId && queueAliases.get(sessionId)) || sessionId;
+  const queue = key ? queues.get(key) : null;
+  if (!queue) return { running: false, items: [] };
+  return {
+    running: !!queue.running,
+    items: queue.items.map(item => String(item?.command || '')).filter(Boolean),
+  };
+}
+
+/** Drop follow-ups that have not started yet. The active ACP prompt is aborted
+ * by app.js through its active-session entry. */
+export function cancelGrokQueue(sessionId) {
+  const key = (sessionId && queueAliases.get(sessionId)) || sessionId;
+  const queue = key ? queues.get(key) : null;
+  if (!queue) return 0;
+  const count = queue.items.length;
+  queue.items.length = 0;
+  return count;
+}
+
 function profileKey(options) {
   return `${options.model || ''}\u001f${options.effort || ''}`;
 }

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/models.js

@@ -6,6 +6,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
 import { execFile } from 'child_process';
+import { pickAllowedEnv, loadAgentEnvFile, readSettingsJsonEnv } from '../agent-env.js';
 
 /** Static fallbacks when local cache/config is missing. */
 export const FALLBACK_MODELS = {
@@ -168,6 +169,34 @@ async function discoverClaude(claudeConfigDirs = []) {
   let defaultModel = null;
   const sources = [];
 
+  const envLayers = [
+    pickAllowedEnv(process.env),
+    await loadAgentEnvFile(),
+  ];
+  for (const dir of dirs) {
+    envLayers.push(await readSettingsJsonEnv(dir));
+  }
+  const envMerged = Object.assign({}, ...envLayers);
+  const envModelKeys = [
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_SMALL_FAST_MODEL',
+    'CLAUDE_CODE_SUBAGENT_MODEL',
+    'CLAUDE_MODEL',
+  ];
+  for (const k of envModelKeys) {
+    const v = envMerged[k];
+    if (typeof v === 'string' && v.trim()) {
+      found.push({ value: v.trim(), label: shortLabel(v.trim()) });
+      if ((k === 'ANTHROPIC_MODEL' || k === 'CLAUDE_MODEL') && !defaultModel) {
+        defaultModel = v.trim();
+      }
+    }
+  }
+  if (found.length) sources.push('env');
+
   for (const dir of dirs) {
     for (const name of ['settings.json', 'settings.local.json']) {
       const data = await readJson(path.join(dir, name));
@@ -202,7 +231,7 @@ async function discoverClaude(claudeConfigDirs = []) {
   let models = uniqModels(found);
   let source = 'fallback';
   if (models.length) {
-    source = 'settings';
+    source = envMerged.ANTHROPIC_BASE_URL ? 'anthropic-compat' : 'settings';
     // Custom gateway / third-party models: list only what is configured
   } else {
     models = FALLBACK_MODELS.claude.models.map(m => ({ ...m }));

package/src/agents/sessions.js

@@ -1644,14 +1644,24 @@ export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codex
   return { cwd, display };
 }
 
-export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
+/**
+ * Copy a session into a new native transcript. `upTo` is an exclusive message
+ * count, used by message-level forks to copy only the selected conversation
+ * prefix. Keeping this here (rather than slicing in the browser) makes the
+ * server-owned transcript the source of truth.
+ */
+export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { upTo = null } = {}) {
   // 1. Get meta and messages from source session
   const meta = await getSessionMeta(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
   const cwd = meta.cwd || null;
   const display = meta.display || 'Converted Session';
   
   const bundle = await loadSessionMessages(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
-  const messages = bundle.messages || [];
+  let messages = bundle.messages || [];
+  if (Number.isInteger(upTo)) {
+    messages = messages.slice(0, Math.max(0, Math.min(upTo, messages.length)));
+  }
+  if (!messages.length) throw new Error('No messages available at the selected fork point');
 
   // 2. Generate target session ID
   const targetSessionId = crypto.randomUUID();