claude-simple 0.2.25 → 0.2.26

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/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;

package/src/collab.js

@@ -15,6 +15,12 @@ export function roleAtLeast(have, need) {
 export function createCollab({ filePath }) {
   let data = { users: [], locks: {}, routes: {} };
   let loaded = false;
+  let chain = Promise.resolve();
+  function withMutex(fn) {
+    const run = chain.then(fn, fn);
+    chain = run.then(() => undefined, () => undefined);
+    return run;
+  }
 
   async function load() {
     if (loaded) return data;
@@ -49,82 +55,95 @@ export function createCollab({ filePath }) {
   function token() { return crypto.randomBytes(16).toString('hex'); }
 
   async function acquire({ key, kind, holder, holderRole, lockToken, ttlMs, exclusive = true }) {
-    await load();
-    purgeLocks();
-    if (!roleAtLeast(holderRole, 'editor')) {
-      return { code: 403, error: 'viewers cannot take exclusive locks' };
-    }
-    if (!key) return { code: 400, error: 'key required' };
-    ttlMs = Math.min(Math.max(ttlMs || DEFAULT_TTL_MS, 5_000), 5 * 60_000);
-    const cur = data.locks[key];
-    if (!cur) {
-      const l = {
-        key, kind, holder, holderRole,
-        token: lockToken || token(),
-        exclusive, acquiredAt: now(), expiresAt: now() + ttlMs, version: 1,
-      };
-      data.locks[key] = l;
-      await save();
-      return { code: 200, lock: { ...l } };
-    }
-    if (cur.holder === holder && (!lockToken || lockToken === cur.token)) {
-      cur.expiresAt = now() + ttlMs;
-      if (!lockToken) {
-        cur.token = token();
-        cur.version += 1;
+    return withMutex(async () => {
+      await load();
+      purgeLocks();
+      if (!roleAtLeast(holderRole, 'editor')) {
+        return { code: 403, error: 'viewers cannot take exclusive locks' };
       }
-      await save();
-      return { code: 200, lock: { ...cur } };
-    }
-    const pub = { ...cur, token: undefined };
-    return { code: 423, error: 'locked', lock: pub };
+      if (!key) return { code: 400, error: 'key required' };
+      ttlMs = Math.min(Math.max(ttlMs || DEFAULT_TTL_MS, 5_000), 5 * 60_000);
+      const cur = data.locks[key];
+      if (!cur) {
+        const l = {
+          key, kind, holder, holderRole,
+          token: lockToken || token(),
+          exclusive, acquiredAt: now(), expiresAt: now() + ttlMs, version: 1,
+        };
+        data.locks[key] = l;
+        await save();
+        return { code: 200, lock: { ...l } };
+      }
+      // Same principal always reclaims. Never rotate the token on a token-less
+      // refresh: rotating locked the holder's other tabs out of their own session.
+      if (cur.holder === holder) {
+        cur.expiresAt = now() + ttlMs;
+        cur.holderRole = holderRole || cur.holderRole;
+        await save();
+        return { code: 200, lock: { ...cur } };
+      }
+      const pub = { ...cur, token: undefined };
+      return { code: 423, error: 'locked', lock: pub };
+    });
   }
 
   async function heartbeat({ key, holder, lockToken, ttlMs }) {
-    await load();
-    purgeLocks();
-    const cur = data.locks[key];
-    if (!cur) return { code: 404, error: 'no lock' };
-    if (cur.holder !== holder || cur.token !== lockToken) {
-      return { code: 409, error: 'token mismatch' };
-    }
-    cur.expiresAt = now() + (ttlMs || DEFAULT_TTL_MS);
-    await save();
-    return { code: 200, lock: { ...cur } };
+    return withMutex(async () => {
+      await load();
+      purgeLocks();
+      const cur = data.locks[key];
+      if (!cur) return { code: 404, error: 'no lock' };
+      if (cur.holder !== holder || cur.token !== lockToken) {
+        return { code: 409, error: 'token mismatch' };
+      }
+      cur.expiresAt = now() + (ttlMs || DEFAULT_TTL_MS);
+      await save();
+      return { code: 200, lock: { ...cur } };
+    });
   }
 
   async function release({ key, holder, lockToken, force }) {
-    await load();
-    const cur = data.locks[key];
-    if (!cur) return { code: 200 };
-    if (!force && (cur.holder !== holder || cur.token !== lockToken)) {
-      return { code: 409, error: 'token mismatch' };
-    }
-    delete data.locks[key];
-    await save();
-    return { code: 200 };
+    return withMutex(async () => {
+      await load();
+      const cur = data.locks[key];
+      if (!cur) return { code: 200 };
+      // Holder can drop their own lease without presenting the token (Flutter
+      // lock list has no stored token). Anyone else needs force-break.
+      if (!force && cur.holder !== holder) {
+        return { code: 409, error: 'token mismatch' };
+      }
+      delete data.locks[key];
+      await save();
+      return { code: 200 };
+    });
   }
 
   async function requireLock({ key, lockToken, writer, writerRole }) {
-    await load();
-    purgeLocks();
-    let cur = data.locks[key];
-    if (!cur) {
-      const l = {
-        key, kind: 'auto', holder: writer, holderRole: writerRole,
-        token: lockToken || token(), exclusive: true,
-        acquiredAt: now(), expiresAt: now() + AUTO_CLAIM_MS, version: 1,
-      };
-      data.locks[key] = l;
-      await save();
-      return { code: 200, lock: { ...l } };
-    }
-    if (cur.holder !== writer || (lockToken && lockToken !== cur.token)) {
+    return withMutex(async () => {
+      await load();
+      purgeLocks();
+      if (!roleAtLeast(writerRole, 'editor')) {
+        return { code: 403, error: 'forbidden' };
+      }
+      let cur = data.locks[key];
+      if (!cur) {
+        const l = {
+          key, kind: 'auto', holder: writer, holderRole: writerRole,
+          token: lockToken || token(), exclusive: true,
+          acquiredAt: now(), expiresAt: now() + AUTO_CLAIM_MS, version: 1,
+        };
+        data.locks[key] = l;
+        await save();
+        return { code: 200, lock: { ...l } };
+      }
+      // Same holder may omit or present a stale token; they already own the lease.
+      if (cur.holder === writer) {
+        cur.expiresAt = now() + DEFAULT_TTL_MS;
+        await save();
+        return { code: 200, lock: { ...cur } };
+      }
       return { code: 423, error: 'locked', lock: { ...cur, token: undefined } };
-    }
-    cur.expiresAt = now() + DEFAULT_TTL_MS;
-    await save();
-    return { code: 200, lock: { ...cur } };
+    });
   }
 
   async function listLocks() {

package/src/runtime/protocol.js

@@ -27,6 +27,9 @@ export function normalizeCommand(msg) {
       requestId: msg.requestId || null,
       allow: msg.allow,
       always: msg.always,
+      // An immediate replacement turn keeps any server-side follow-ups. This
+      // is opt-in; the legacy Stop action continues to discard them.
+      preserveQueue: msg.preserveQueue === true,
       cwd: msg.cwd || msg.options?.cwd || null,
     };
   }
@@ -42,6 +45,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: msg.options?.cwd || null,
     };
   }
@@ -57,6 +61,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: null,
     };
   }
@@ -72,6 +77,7 @@ export function normalizeCommand(msg) {
       requestId: msg.requestId || msg.request_id,
       allow: msg.allow !== false && msg.allow !== 0 && msg.allow !== '0',
       always: !!msg.always,
+      preserveQueue: false,
       cwd: null,
     };
   }
@@ -87,6 +93,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: msg.cwd || null,
     };
   }
@@ -102,6 +109,7 @@ export function normalizeCommand(msg) {
       requestId: null,
       allow: undefined,
       always: false,
+      preserveQueue: false,
       cwd: null,
     };
   }