claude-simple 0.1.0 → 0.2.0

package/src/agents/stream-batch.js

@@ -0,0 +1,62 @@
+/**
+ * Coalesce chatty stream chunks into fewer WebSocket frames.
+ * Keeps UI latency low (flush on size or ~maxWait ms) while cutting
+ * mobile tunnel traffic: each JSON frame has fixed tunnel/header overhead.
+ */
+export function createDeltaBatcher(send, type, extra = {}, opts = {}) {
+  const maxWait = opts.maxWait ?? 48;
+  const maxSize = opts.maxSize ?? 480;
+  let buf = '';
+  let timer = null;
+
+  function flush() {
+    if (timer) { clearTimeout(timer); timer = null; }
+    if (!buf) return;
+    const data = buf;
+    buf = '';
+    send({ type, data, ...extra });
+  }
+
+  return {
+    push(chunk) {
+      if (chunk == null || chunk === '') return;
+      buf += String(chunk);
+      if (buf.length >= maxSize) {
+        flush();
+        return;
+      }
+      if (!timer) timer = setTimeout(flush, maxWait);
+    },
+    flush,
+    pending() { return buf.length; },
+  };
+}
+
+/** Batch raw text for shell / terminal style streams. */
+export function createTextBatcher(sendFn, opts = {}) {
+  const maxWait = opts.maxWait ?? 32;
+  const maxSize = opts.maxSize ?? 2048;
+  let buf = '';
+  let timer = null;
+
+  function flush() {
+    if (timer) { clearTimeout(timer); timer = null; }
+    if (!buf) return;
+    const data = buf;
+    buf = '';
+    sendFn(data);
+  }
+
+  return {
+    push(chunk) {
+      if (chunk == null || chunk === '') return;
+      buf += String(chunk);
+      if (buf.length >= maxSize) {
+        flush();
+        return;
+      }
+      if (!timer) timer = setTimeout(flush, maxWait);
+    },
+    flush,
+  };
+}

package/src/app.js

@@ -9,6 +9,7 @@ import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
+import zlib from 'zlib';
 import { fileURLToPath } from 'url';
 import { runClaude } from './agents/claude.js';
 import { runCodex } from './agents/codex.js';
@@ -25,6 +26,10 @@ import {
 } from './agents/sessions.js';
 import { createMetaAgent } from './agents/meta-agent.js';
 import { discoverAllAgentModels } from './agents/models.js';
+import { createTextBatcher } from './agents/stream-batch.js';
+import { normalizeCommand, mapAgentEmit } from './runtime/protocol.js';
+import { createOutbox } from './runtime/outbox.js';
+import { resolveApproval, cancelApprovalsForSession } from './runtime/approvals.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.join(__dirname, '..');
 
@@ -269,6 +274,27 @@ async function isGitRepo(dir) {
 
 // ─── Active agent sessions ────────────────────────────────────────────────────
 const activeSessions = new Map();
+/** Live chat sockets so a mobile reconnect can resume an in-flight run. */
+const chatClients = new Set();
+
+function sendJson(ws, data) {
+  if (ws.readyState === ws.OPEN) {
+    try { ws.send(JSON.stringify(data)); } catch { /* ignore */ }
+  }
+}
+
+function broadcastChat(sessionId, data, fallbackWs) {
+  let n = 0;
+  if (sessionId) {
+    for (const c of chatClients) {
+      if (c.sessionId === sessionId) {
+        sendJson(c.ws, data);
+        n++;
+      }
+    }
+  }
+  if (n === 0 && fallbackWs) sendJson(fallbackWs, data);
+}
 
 async function listSessions(filterCwd = null, agentFilter = null) {
   const agents = agentFilter
@@ -283,6 +309,21 @@ async function listSessions(filterCwd = null, agentFilter = null) {
   });
 }
 
+/**
+ * Wrap agent emit → map/filter → outbox (delta coalesce + batch frames).
+ * Agents may still call send() with UI-shaped events; unknown noise is dropped.
+ */
+function createAgentSend(outbox, agent) {
+  return (data) => {
+    const mapped = mapAgentEmit(data, { agent, compactTools: true });
+    // permission_request / already-mapped events: mapAgentEmit keeps known types
+    if (mapped) outbox.send(mapped);
+    else if (data?.type === 'permission_request' || data?.type === 'permission_resolved') {
+      outbox.send(data);
+    }
+  };
+}
+
 async function dispatchAgent(agent, command, options, send) {
   const a = (agent || 'claude').toLowerCase();
   if (!ENABLED_AGENTS.includes(a)) {
@@ -300,20 +341,86 @@ async function dispatchAgent(agent, command, options, send) {
 }
 
 function abortSession(sessionId) {
-  const s = activeSessions.get(sessionId);
-  if (!s) return false;
-  if (s.controller) s.controller.abort();
-  if (typeof s.abort === 'function') s.abort();
-  else if (s.child) {
-    try { s.child.kill('SIGTERM'); } catch {}
+  if (!sessionId) return false;
+  let ok = false;
+  cancelApprovalsForSession(sessionId);
+  // Grok/Codex may register under temp key + real sessionId — abort every match.
+  for (const [key, s] of activeSessions) {
+    if (key !== sessionId && s?.sessionId !== sessionId && s?.key !== sessionId) continue;
+    if (s.controller) s.controller.abort();
+    if (typeof s.abort === 'function') s.abort();
+    else if (s.child) {
+      try { s.child.kill('SIGTERM'); } catch {}
+    }
+    s.busy = false;
+    ok = true;
+  }
+  return ok;
+}
+
+/** Whether a session still has an in-flight UI-blocking run. */
+function isSessionBusy(sessionId) {
+  if (!sessionId) return false;
+  for (const [key, s] of activeSessions) {
+    if (key !== sessionId && s?.sessionId !== sessionId) continue;
+    if (s && s.busy !== false) return true;
+  }
+  return false;
+}
+
+function markSessionIdle(sessionId, tempKey) {
+  for (const key of [sessionId, tempKey].filter(Boolean)) {
+    const s = activeSessions.get(key);
+    if (s) s.busy = false;
   }
-  return true;
+}
+
+/** Shrink history payloads: huge tool inputs dominate mobile transfers. */
+function compactHistoryMessages(messages) {
+  if (!Array.isArray(messages)) return messages;
+  return messages.map((m) => {
+    if (!m || typeof m !== 'object') return m;
+    if (m.type === 'tool_use' && m.input != null) {
+      let raw;
+      try { raw = typeof m.input === 'string' ? m.input : JSON.stringify(m.input); }
+      catch { raw = String(m.input); }
+      if (raw.length > 1600) {
+        return { ...m, input: { _truncated: true, preview: raw.slice(0, 1600), bytes: raw.length } };
+      }
+    }
+    if (m.type === 'text' && typeof m.content === 'string' && m.content.length > 48_000) {
+      return { ...m, content: `${m.content.slice(0, 48_000)}\n…` };
+    }
+    return m;
+  });
 }
 
 // ─── App factory ──────────────────────────────────────────────────────────────
 export function createApp() {
   const app = express();
 
+  // Gzip JSON/text API responses when client accepts it (hub tunnel + mobile).
+  app.use((req, res, next) => {
+    const ae = req.headers['accept-encoding'] || '';
+    if (!/\bgzip\b/i.test(ae) || req.method === 'HEAD') return next();
+    const origJson = res.json.bind(res);
+    res.json = (body) => {
+      let buf;
+      try { buf = Buffer.from(typeof body === 'string' ? body : JSON.stringify(body)); }
+      catch { return origJson(body); }
+      if (buf.length < 900) return origJson(body);
+      zlib.gzip(buf, { level: 6 }, (err, zipped) => {
+        if (err || !zipped || zipped.length >= buf.length * 0.95) return origJson(body);
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.setHeader('Content-Encoding', 'gzip');
+        res.setHeader('Vary', 'Accept-Encoding');
+        res.setHeader('Content-Length', zipped.length);
+        res.status(res.statusCode || 200).end(zipped);
+      });
+    };
+    next();
+  });
+
   app.post('/api/upload-image', authMiddleware, (req, res) => {
     (async () => {
       const ext  = (req.headers['x-filename'] || 'image.png').split('.').pop().replace(/[^a-z0-9]/gi, '') || 'png';
@@ -641,11 +748,11 @@ export function createApp() {
 
   app.put('/api/sessions/meta', authMiddleware, async (req, res) => {
     try {
-      const { sessionId, agent, favorite, notes, title } = req.body || {};
+      const { sessionId, agent, favorite, notes, title, hidden } = req.body || {};
       if (!sessionId) return res.status(400).json({ error: 'sessionId required' });
       const key = sessionMetaKey(agent || 'claude', sessionId);
       const db = await loadSessionMeta();
-      const prev = db[key] || { favorite: false, notes: '', title: '', updatedAt: 0 };
+      const prev = db[key] || { favorite: false, notes: '', title: '', hidden: false, updatedAt: 0 };
       const next = {
         favorite: favorite !== undefined ? Boolean(favorite) : Boolean(prev.favorite),
         notes: notes !== undefined ? String(notes || '') : String(prev.notes || ''),
@@ -653,10 +760,11 @@ export function createApp() {
         title: title !== undefined
           ? String(title || '').trim().slice(0, 200)
           : String(prev.title || '').trim(),
+        hidden: hidden !== undefined ? Boolean(hidden) : Boolean(prev.hidden),
         updatedAt: Date.now(),
       };
       // Drop empty entries to keep file small
-      if (!next.favorite && !next.notes && !next.title) {
+      if (!next.favorite && !next.notes && !next.title && !next.hidden) {
         delete db[key];
       } else {
         db[key] = next;
@@ -665,7 +773,7 @@ export function createApp() {
       res.json({
         success: true,
         key,
-        ...(db[key] || { favorite: false, notes: '', title: '', updatedAt: Date.now() }),
+        ...(db[key] || { favorite: false, notes: '', title: '', hidden: false, updatedAt: Date.now() }),
       });
     } catch (e) { res.status(500).json({ error: e.message }); }
   });
@@ -701,8 +809,21 @@ export function createApp() {
     try {
       const filterCwd = typeof req.query.cwd === 'string' ? req.query.cwd : null;
       const agent = typeof req.query.agent === 'string' ? req.query.agent : null;
-      const sessions = await listSessions(filterCwd || null, agent);
-      res.json(sessions.map(toClientSession));
+      const days = parseInt(req.query.days || '0', 10) || 0;
+      let limit = parseInt(req.query.limit || '0', 10) || 0;
+      if (limit < 0) limit = 0;
+      if (limit > 800) limit = 800;
+      let sessions = (await listSessions(filterCwd || null, agent)).map(toClientSession);
+      if (days > 0) {
+        const since = Date.now() - days * 86400000;
+        sessions = sessions.filter(s => (s.updatedAt || 0) >= since);
+      }
+      if (limit > 0 && sessions.length > limit) sessions = sessions.slice(0, limit);
+      const etag = `"s${crypto.createHash('sha1').update(JSON.stringify(sessions)).digest('base64url').slice(0, 20)}"`;
+      res.setHeader('ETag', etag);
+      res.setHeader('Cache-Control', 'private, max-age=15');
+      if (req.headers['if-none-match'] === etag) return res.status(304).end();
+      res.json(sessions);
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
@@ -752,11 +873,12 @@ 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 last 120 messages for fast first paint
-      let tail = parseInt(req.query.tail ?? '120', 10);
-      if (Number.isNaN(tail)) tail = 120;
+      // tail=0 → full history; default last 80 messages (mobile-friendly)
+      let tail = parseInt(req.query.tail ?? '80', 10);
+      if (Number.isNaN(tail)) tail = 80;
       if (tail < 0) tail = 0;
       if (tail > 2000) tail = 2000;
+      const compact = req.query.compact !== '0' && req.query.compact !== 'false';
       const opts = {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
@@ -782,6 +904,7 @@ export function createApp() {
         messages = messages.slice(-tail);
         truncated = true;
       }
+      if (compact) messages = compactHistoryMessages(messages);
       const payload = {
         messages,
         context: Array.isArray(bundle) ? null : (bundle.context || null),
@@ -789,6 +912,7 @@ export function createApp() {
         total,
         truncated,
         tail: truncated ? tail : total,
+        compact,
       };
       res.setHeader('X-Session-Agent', payload.agent);
       res.setHeader('Cache-Control', 'private, max-age=30');
@@ -1059,6 +1183,7 @@ export function createApp() {
       const result = await meta.runLoop(msgs, {
         chatSessionId: session.id,
         onContent: (content) => sseWrite(res, 'content', { content }),
+        onApproval: ({ id, name, args }) => sseWrite(res, 'approval', { id, name, args }),
         onTool: (name, args, phase, toolResult, id) => {
           if (name === 'analyze_images' && phase === 'done' && toolResult?.thread_id) {
             if (!session.vlmThreadIds.includes(toolResult.thread_id)) {
@@ -1095,10 +1220,31 @@ export function createApp() {
     }
   });
 
+  // User approves/denies a pending sensitive tool call (e.g. run_command) from /api/ai/chat.
+  app.post('/api/ai/approve', authMiddleware, async (req, res) => {
+    const { id, approved } = req.body || {};
+    if (!id) return res.status(400).json({ error: 'id required' });
+    const ok = meta.resolveApproval(id, !!approved);
+    if (!ok) return res.status(404).json({ error: 'no pending approval for id (may have timed out)' });
+    res.json({ ok: true });
+  });
+
   // ─── HTTP + WebSocket server ─────────────────────────────────────────────────
   const server = http.createServer(app);
-  const wssChat  = new WebSocketServer({ noServer: true });
-  const wssShell = new WebSocketServer({ noServer: true });
+  const wssOpts = {
+    noServer: true,
+    perMessageDeflate: {
+      zlibDeflateOptions: { chunkSize: 1024, memLevel: 7, level: 3 },
+      zlibInflateOptions: { chunkSize: 10 * 1024 },
+      clientNoContextTakeover: true,
+      serverNoContextTakeover: true,
+      serverMaxWindowBits: 10,
+      concurrencyLimit: 8,
+      threshold: 256,
+    },
+  };
+  const wssChat  = new WebSocketServer(wssOpts);
+  const wssShell = new WebSocketServer(wssOpts);
 
   server.on('upgrade', (req, socket, head) => {
     const pathname = new URL(req.url, 'http://localhost').pathname;
@@ -1127,41 +1273,154 @@ export function createApp() {
       return;
     }
 
-    const send = (data) => {
-      if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(data));
+    const client = { ws, sessionId: url.searchParams.get('sessionId') || null };
+    chatClients.add(client);
+
+    // Broadcast to every chat socket on the same session (mobile reconnect / multi-tab).
+    const deliver = (data) => {
+      if (data?.sessionId) client.sessionId = data.sessionId;
+      broadcastChat(client.sessionId, data, ws);
     };
 
     let shellProc = null;
+    let shellOut = null;
+    let shellErr = null;
+    // App-level ping only (JSON survives hub tunnel). Interval kept modest for mobile radio.
+    const heartbeat = setInterval(() => {
+      if (ws.readyState !== ws.OPEN) return;
+      sendJson(ws, { type: 'ping' });
+    }, 35_000);
+
+    // Low-pressure outbox: coalesce deltas + optional multi-event batch frames
+    const outbox = createOutbox(deliver, {
+      maxWait: 48,
+      maxDeltaChars: 720,
+      maxBatchItems: 10,
+      maxBatchBytes: 10_000,
+    });
+    const wireSend = (data) => outbox.send(data);
 
     ws.on('message', async (raw) => {
       let msg;
       try { msg = JSON.parse(raw.toString()); }
       catch { return; }
 
-      if (msg.type === 'claude-command' || msg.type === 'agent-command') {
-        const agent = msg.agent || msg.options?.agent || 'claude';
-        await dispatchAgent(agent, msg.command || '', msg.options || {}, send);
-      } else if (msg.type === 'shell-command') {
+      if (msg.type === 'ping') {
+        sendJson(ws, { type: 'pong' });
+        return;
+      }
+      if (msg.type === 'pong') return;
+
+      const cmd = normalizeCommand(msg);
+      if (!cmd) return;
+
+      if (cmd.cmd === 'session.subscribe') {
+        client.sessionId = cmd.sessionId || client.sessionId || null;
+        wireSend({
+          type: 'run-status',
+          sessionId: client.sessionId,
+          running: isSessionBusy(client.sessionId),
+        });
+        outbox.flush();
+        return;
+      }
+
+      if (cmd.cmd === 'approval.respond') {
+        const ok = resolveApproval(cmd.requestId, { allow: cmd.allow, always: cmd.always });
+        if (cmd.requestId) {
+          const elHint = { type: 'permission_resolved', requestId: cmd.requestId, allow: !!cmd.allow };
+          wireSend(elHint);
+        }
+        if (!ok) {
+          wireSend({ type: 'status', message: 'permission request expired or unknown' });
+        }
+        outbox.flush();
+        return;
+      }
+
+      if (cmd.cmd === 'turn.interrupt') {
+        const sid = cmd.sessionId;
+        const ok = abortSession(sid);
+        wireSend({ type: 'abort-result', success: ok, sessionId: sid });
+        outbox.flush();
+        return;
+      }
+
+      if (cmd.cmd === 'turn.start') {
+        const agent = cmd.agent || 'claude';
+        const options = { ...cmd.options };
+        if (cmd.sessionId) options.sessionId = cmd.sessionId;
+        if (cmd.cwd) options.cwd = cmd.cwd;
+        if (options.sessionId) client.sessionId = options.sessionId;
+        const agentSend = createAgentSend(outbox, agent);
+        const runSend = (data) => {
+          if (data?.type === 'result' || data?.type === 'complete' || data?.type === 'error') {
+            markSessionIdle(data.sessionId || client.sessionId, options.sessionId);
+            outbox.flush();
+          }
+          if (data?.sessionId) client.sessionId = data.sessionId;
+          if (data?.type === 'session-created' && data.sessionId) client.sessionId = data.sessionId;
+          // permission_request bypasses map filter double-pass carefully
+          if (data?.type === 'permission_request' || data?.type === 'permission_resolved') {
+            outbox.send(data);
+            outbox.flush();
+            return;
+          }
+          agentSend(data);
+        };
+        await dispatchAgent(agent, cmd.command || '', options, runSend);
+        outbox.flush();
+        return;
+      }
+
+      if (cmd.cmd === 'shell.exec') {
         if (shellProc) { try { shellProc.kill(); } catch {} shellProc = null; }
-        const cmd = msg.command || '';
-        const cwd = msg.cwd || os.homedir();
-        send({ type: 'shell-start', command: cmd });
-        shellProc = spawn(process.env.SHELL || 'bash', ['-c', cmd], {
+        shellOut?.flush();
+        shellErr?.flush();
+        const shellCmd = cmd.command || '';
+        const cwd = cmd.cwd || os.homedir();
+        wireSend({ type: 'shell-start', command: shellCmd });
+        shellProc = spawn(process.env.SHELL || 'bash', ['-c', shellCmd], {
           cwd,
           env: { ...process.env },
           shell: false,
         });
-        shellProc.stdout.on('data', d => send({ type: 'shell-output', stream: 'stdout', data: d.toString() }));
-        shellProc.stderr.on('data', d => send({ type: 'shell-output', stream: 'stderr', data: d.toString() }));
-        shellProc.on('close', (code) => { send({ type: 'shell-exit', code }); shellProc = null; });
-        shellProc.on('error', (e) => { send({ type: 'shell-exit', code: 1, error: e.message }); shellProc = null; });
-      } else if (msg.type === 'abort-session') {
-        const ok = abortSession(msg.sessionId);
-        send({ type: 'abort-result', success: ok, sessionId: msg.sessionId });
+        shellOut = createTextBatcher(
+          (data) => wireSend({ type: 'shell-output', stream: 'stdout', data }),
+          { maxWait: 48, maxSize: 3072 },
+        );
+        shellErr = createTextBatcher(
+          (data) => wireSend({ type: 'shell-output', stream: 'stderr', data }),
+          { maxWait: 48, maxSize: 3072 },
+        );
+        shellProc.stdout.on('data', d => shellOut.push(d.toString()));
+        shellProc.stderr.on('data', d => shellErr.push(d.toString()));
+        shellProc.on('close', (code) => {
+          shellOut?.flush();
+          shellErr?.flush();
+          wireSend({ type: 'shell-exit', code });
+          outbox.flush();
+          shellProc = null;
+        });
+        shellProc.on('error', (e) => {
+          shellOut?.flush();
+          shellErr?.flush();
+          wireSend({ type: 'shell-exit', code: 1, error: e.message });
+          outbox.flush();
+          shellProc = null;
+        });
+        return;
       }
     });
 
-    ws.on('close', () => { if (shellProc) { try { shellProc.kill(); } catch {} } });
+    ws.on('close', () => {
+      chatClients.delete(client);
+      clearInterval(heartbeat);
+      outbox.flush();
+      shellOut?.flush();
+      shellErr?.flush();
+      if (shellProc) { try { shellProc.kill(); } catch {} }
+    });
     ws.on('error', (e) => console.error('[ws]', e.message));
   });
 
@@ -1249,10 +1508,14 @@ else:
       return;
     }
 
-    proc.stdout.on('data', d => send({ type: 'output', data: d.toString() }));
-    proc.stderr.on('data', d => send({ type: 'output', data: d.toString() }));
-    proc.on('exit',  (code) => { send({ type: 'exit', code }); ws.close(); });
-    proc.on('error', (e)    => { send({ type: 'error', data: e.message }); });
+    const outBatch = createTextBatcher(
+      (data) => send({ type: 'output', data }),
+      { maxWait: 28, maxSize: 3072 },
+    );
+    proc.stdout.on('data', d => outBatch.push(d.toString()));
+    proc.stderr.on('data', d => outBatch.push(d.toString()));
+    proc.on('exit',  (code) => { outBatch.flush(); send({ type: 'exit', code }); ws.close(); });
+    proc.on('error', (e)    => { outBatch.flush(); send({ type: 'error', data: e.message }); });
 
     ws.on('message', raw => {
       let msg; try { msg = JSON.parse(raw.toString()); } catch { return; }
@@ -1263,7 +1526,7 @@ else:
       }
     });
 
-    ws.on('close', () => { try { proc.kill('SIGHUP'); } catch {} });
+    ws.on('close', () => { outBatch.flush(); try { proc.kill('SIGHUP'); } catch {} });
     ws.on('error', e => console.error('[ws/shell]', e.message));
   });
 

package/src/runtime/approvals.js

@@ -0,0 +1,67 @@
+/**
+ * In-flight tool permission requests (Claude canUseTool bridge).
+ * requestId → { resolve, reject, sessionId, createdAt }
+ */
+
+const pending = new Map();
+
+const DEFAULT_TTL_MS = 10 * 60 * 1000;
+
+/**
+ * @param {string} requestId
+ * @param {string | null} sessionId
+ * @param {number} [ttlMs]
+ * @returns {Promise<{ allow: boolean, always?: boolean }>}
+ */
+export function waitForApproval(requestId, sessionId, ttlMs = DEFAULT_TTL_MS) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(requestId);
+      resolve({ allow: false, always: false, timeout: true });
+    }, ttlMs);
+
+    pending.set(requestId, {
+      resolve: (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      reject: (e) => {
+        clearTimeout(timer);
+        reject(e);
+      },
+      sessionId: sessionId || null,
+      createdAt: Date.now(),
+    });
+  });
+}
+
+/**
+ * @param {string} requestId
+ * @param {{ allow: boolean, always?: boolean }} decision
+ * @returns {boolean}
+ */
+export function resolveApproval(requestId, decision) {
+  const entry = pending.get(requestId);
+  if (!entry) return false;
+  pending.delete(requestId);
+  entry.resolve({
+    allow: !!decision.allow,
+    always: !!decision.always,
+  });
+  return true;
+}
+
+/** Drop pending approvals for a session (on interrupt). */
+export function cancelApprovalsForSession(sessionId) {
+  if (!sessionId) return;
+  for (const [id, entry] of pending) {
+    if (entry.sessionId === sessionId || entry.sessionId == null) {
+      pending.delete(id);
+      entry.resolve({ allow: false, always: false, cancelled: true });
+    }
+  }
+}
+
+export function pendingApprovalCount() {
+  return pending.size;
+}