glad-web 1.0.29 → 1.0.31

package/lib/claude/cli-usage.js

@@ -0,0 +1,95 @@
+function stripTerminalFormatting(value) {
+  return String(value || '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\r/g, '');
+}
+
+function parseTokenCount(value) {
+  const text = String(value || '').trim().replace(/,/g, '');
+  const match = text.match(/^([\d.]+)\s*([kmb])?$/i);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount)) return null;
+  const multiplier = { k: 1_000, m: 1_000_000, b: 1_000_000_000 }[String(match[2] || '').toLowerCase()] || 1;
+  return Math.round(amount * multiplier);
+}
+
+function parseClaudeUsageOutput(output) {
+  const text = stripTerminalFormatting(output);
+  const cost = text.match(/Total cost:\s*\$([\d,.]+)/i);
+  const apiDuration = text.match(/Total duration \(API\):\s*([^\n]+)/i);
+  const wallDuration = text.match(/Total duration \(wall\):\s*([^\n]+)/i);
+  const codeChanges = text.match(/Total code changes:\s*([\d,]+) lines added,\s*([\d,]+) lines removed/i);
+  const tokens = text.match(/Usage:\s*([\d,.kmb]+) input,\s*([\d,.kmb]+) output,\s*([\d,.kmb]+) cache read,\s*([\d,.kmb]+) cache write/i);
+  const models = [];
+  const modelPattern = /^\s*(.+?):\s*([\d,.kmb]+) input,\s*([\d,.kmb]+) output,\s*([\d,.kmb]+) cache read,\s*([\d,.kmb]+) cache write(?:\s*\(\$([\d,.]+)\))?\s*$/gim;
+  for (const match of text.matchAll(modelPattern)) {
+    if (/^Usage$/i.test(match[1].trim())) continue;
+    models.push({
+      model: match[1].trim(),
+      inputTokens: parseTokenCount(match[2]),
+      outputTokens: parseTokenCount(match[3]),
+      cacheReadTokens: parseTokenCount(match[4]),
+      cacheWriteTokens: parseTokenCount(match[5]),
+      costUsd: match[6] ? Number(match[6].replace(/,/g, '')) : null
+    });
+  }
+
+  if (!cost && !apiDuration && !wallDuration && !codeChanges && !tokens && models.length === 0) {
+    throw new Error('Claude CLI returned an unrecognized /usage response');
+  }
+
+  const totalModelValue = key => models.length > 0
+    ? models.reduce((sum, model) => sum + Number(model[key] || 0), 0)
+    : null;
+
+  return {
+    totalCostUsd: cost ? Number(cost[1].replace(/,/g, '')) : null,
+    apiDuration: apiDuration ? apiDuration[1].trim() : null,
+    wallDuration: wallDuration ? wallDuration[1].trim() : null,
+    linesAdded: codeChanges ? Number(codeChanges[1].replace(/,/g, '')) : null,
+    linesRemoved: codeChanges ? Number(codeChanges[2].replace(/,/g, '')) : null,
+    inputTokens: tokens ? parseTokenCount(tokens[1]) : totalModelValue('inputTokens'),
+    outputTokens: tokens ? parseTokenCount(tokens[2]) : totalModelValue('outputTokens'),
+    cacheReadTokens: tokens ? parseTokenCount(tokens[3]) : totalModelValue('cacheReadTokens'),
+    cacheWriteTokens: tokens ? parseTokenCount(tokens[4]) : totalModelValue('cacheWriteTokens'),
+    models
+  };
+}
+
+function parseClaudeContextOutput(output) {
+  const text = stripTerminalFormatting(output);
+  const model = text.match(/^\*\*Model:\*\*\s*(.+?)\s*$/mi);
+  const tokens = text.match(/^\*\*Tokens:\*\*\s*([\d,.]+\s*[kmb]?)\s*\/\s*([\d,.]+\s*[kmb]?)\s*\(([\d.]+)%\)/mi);
+  if (!tokens) throw new Error('Claude CLI returned an unrecognized /context response');
+
+  const usedTokens = parseTokenCount(tokens[1]);
+  const maxTokens = parseTokenCount(tokens[2]);
+  const categories = [];
+  for (const line of text.split('\n')) {
+    const columns = line.split('|').slice(1, -1).map(value => value.trim());
+    if (columns.length < 3 || !columns[0] || /^category$/i.test(columns[0]) || /^-+$/.test(columns[0])) continue;
+    const categoryTokens = parseTokenCount(columns[1]);
+    if (categoryTokens == null || !/^<?[\d.]+%$/.test(columns[2])) continue;
+    categories.push({
+      label: columns[0].replace(/\*\*/g, ''),
+      tokens: categoryTokens,
+      percent: columns[2]
+    });
+  }
+
+  return {
+    model: model ? model[1].trim() : null,
+    usedTokens,
+    maxTokens,
+    usedPercent: Number(tokens[3]),
+    remainingTokens: usedTokens == null || maxTokens == null ? null : Math.max(0, maxTokens - usedTokens),
+    categories
+  };
+}
+
+module.exports = {
+  parseClaudeContextOutput,
+  parseClaudeUsageOutput,
+  parseTokenCount
+};

package/lib/claude/structured-session.js

@@ -1,11 +1,13 @@
 const { EventEmitter } = require('events');
 const crypto = require('crypto');
 const { normalizeEffort, normalizeModel, resolveClaudeModel } = require('./config');
+const { parseClaudeContextOutput, parseClaudeUsageOutput } = require('./cli-usage');
 
 const PERMISSION_MODES = new Set(['default', 'acceptEdits', 'bypassPermissions', 'plan']);
 const EDIT_TOOLS = new Set(['Edit', 'MultiEdit', 'Write', 'NotebookEdit']);
 const EXIT_PLAN_TOOLS = new Set(['exit_plan_mode', 'ExitPlanMode']);
 const DENY_PERMISSION_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+const LOCAL_COMMAND_TIMEOUT_MS = 30_000;
 
 function normalizePermissionMode(value) {
   const mode = String(value || 'default');
@@ -65,7 +67,15 @@ class AsyncMessageQueue {
 }
 
 class ClaudeStructuredSession extends EventEmitter {
-  constructor({ id, tool, workingDir, name, logger, options = {} }) {
+  constructor({
+    id,
+    tool,
+    workingDir,
+    name,
+    logger,
+    options = {},
+    localCommandRunner = null
+  }) {
     super();
     this.id = id;
     this.tool = tool;
@@ -87,7 +97,12 @@ class ClaudeStructuredSession extends EventEmitter {
     this.inputQueue = null;
     this.query = null;
     this.runnerStarted = false;
+    this.runnerReadyPromise = null;
+    this.runnerInitializationAnnounced = false;
     this.abortRequested = false;
+    this.localCommandRunner = localCommandRunner;
+    this.localCommandChain = Promise.resolve();
+    this.pendingLocalCommand = null;
     this.permissionMode = normalizePermissionMode(options.permissionMode);
     this.model = normalizeModel(options.model);
     this.effort = normalizeEffort(options.effort);
@@ -97,8 +112,7 @@ class ClaudeStructuredSession extends EventEmitter {
     this.resumeSessionId = options.resume || null;
     this.claudeSessionId = options.resume || null;
     this.activeOptionSignature = null;
-    this.contextRemaining = null;
-    this.latestUsage = null;
+    this.turnQueue = [];
 
     // Compatibility with existing session-scoped Git/file APIs.
     this.ptyManager = {
@@ -146,8 +160,6 @@ class ClaudeStructuredSession extends EventEmitter {
       status: this.status,
       claudeSessionId: this.claudeSessionId || null,
       resumeSessionId: this.resumeSessionId || null,
-      contextRemaining: this.contextRemaining,
-      latestUsage: this.latestUsage,
       canAbort: this.status === 'thinking',
       pendingPermissionCount: this.pendingPermissions.size
     };
@@ -199,19 +211,29 @@ class ClaudeStructuredSession extends EventEmitter {
     return true;
   }
 
-  sendUserMessage(text) {
+  sendUserMessage(text, attachments = []) {
     if (!this.running) return false;
     const prompt = String(text || '').trim();
-    if (!prompt) return false;
+    const images = Array.isArray(attachments) ? attachments.filter(item => item?.data && item?.mediaType) : [];
+    if (!prompt && images.length === 0) return false;
     this.hasUnreadCompletion = false;
-    this.appendMessage({ kind: 'user', text: prompt });
+    const turn = this.beginTurn(prompt, images.map(item => ({ name: item.name, size: item.size })));
+    this.setStatus('thinking');
+
+    const content = images.length > 0 ? [
+      ...(prompt ? [{ type: 'text', text: prompt }] : []),
+      ...images.map(item => ({
+        type: 'image',
+        source: { type: 'base64', media_type: item.mediaType, data: item.data }
+      }))
+    ] : prompt;
 
     const sdkMessage = {
       type: 'user',
       parent_tool_use_id: null,
       message: {
         role: 'user',
-        content: prompt
+        content
       }
     };
 
@@ -223,6 +245,37 @@ class ClaudeStructuredSession extends EventEmitter {
     return true;
   }
 
+  beginTurn(prompt, attachments = []) {
+    const turn = { id: crypto.randomUUID(), startedAt: Date.now() };
+    this.turnQueue.push(turn);
+    this.appendMessage({ kind: 'turn-start', turnId: turn.id, createdAt: turn.startedAt });
+    this.appendMessage({ kind: 'user', text: prompt, attachments, turnId: turn.id, createdAt: turn.startedAt });
+    return turn;
+  }
+
+  currentTurn() {
+    return this.turnQueue[0] || null;
+  }
+
+  completeCurrentTurn(status = 'completed', reportedDurationMs = null) {
+    const turn = this.turnQueue.shift();
+    if (!turn) return null;
+    const completedAt = Date.now();
+    return this.appendMessage({
+      kind: 'turn-end',
+      turnId: turn.id,
+      turnStatus: status,
+      durationMs: Number.isFinite(Number(reportedDurationMs))
+        ? Math.max(0, Number(reportedDurationMs))
+        : Math.max(0, completedAt - turn.startedAt),
+      createdAt: completedAt
+    });
+  }
+
+  sealTurns(status = 'cancelled') {
+    while (this.turnQueue.length > 0) this.completeCurrentTurn(status);
+  }
+
   createMessageItem(message) {
     return {
       id: crypto.randomUUID(),
@@ -287,10 +340,14 @@ class ClaudeStructuredSession extends EventEmitter {
     this.inputQueue?.close();
     this.query?.close?.();
     this.abortController?.abort();
+    this.rejectPendingLocalCommand(new Error(reason));
     this.runnerStarted = false;
+    this.runnerReadyPromise = null;
+    this.runnerInitializationAnnounced = false;
     this.inputQueue = null;
     this.query = null;
     this.abortController = null;
+    this.sealTurns('cancelled');
     this.setStatus('idle');
     this.appendMessage({ kind: 'event', level: 'info', text: reason });
     this.emitEvent({ type: 'state', state: this.getControlState() });
@@ -300,14 +357,21 @@ class ClaudeStructuredSession extends EventEmitter {
   resetRunnerForNextTurn() {
     this.inputQueue?.close();
     this.query?.close?.();
+    this.rejectPendingLocalCommand(new Error('Claude CLI session was reset'));
     this.runnerStarted = false;
+    this.runnerReadyPromise = null;
+    this.runnerInitializationAnnounced = false;
     this.inputQueue = null;
     this.query = null;
     this.abortController = null;
+    this.turnQueue = [];
   }
 
   finishRunner() {
+    this.rejectPendingLocalCommand(new Error('Claude CLI session ended before returning the command output'));
     this.runnerStarted = false;
+    this.runnerReadyPromise = null;
+    this.runnerInitializationAnnounced = false;
     this.inputQueue?.close();
     this.inputQueue = null;
     this.query = null;
@@ -466,15 +530,27 @@ class ClaudeStructuredSession extends EventEmitter {
     this.completionReadInputSeq = this.inputSeq || 0;
   }
 
-  async startRunner(initialMessage) {
+  startRunner(initialMessage = null) {
+    if (this.runnerStarted) {
+      if (initialMessage && this.inputQueue) this.inputQueue.push(initialMessage);
+      return this.runnerReadyPromise || Promise.resolve(this.query);
+    }
     this.runnerStarted = true;
+    this.runnerInitializationAnnounced = false;
     this.inputQueue = new AsyncMessageQueue();
-    this.inputQueue.push(initialMessage);
+    if (initialMessage) this.inputQueue.push(initialMessage);
     this.abortController = new AbortController();
     this.abortRequested = false;
     this.activeOptionSignature = this.getOptionSignature();
-    this.setStatus('thinking');
+    if (initialMessage) this.setStatus('thinking');
+
+    let resolveReady;
+    this.runnerReadyPromise = new Promise(resolve => { resolveReady = resolve; });
+    void this.runRunner(resolveReady);
+    return this.runnerReadyPromise;
+  }
 
+  async runRunner(resolveReady) {
     try {
       const sdk = await import('@anthropic-ai/claude-agent-sdk');
       const resolvedModel = resolveClaudeModel(this.model, process.env);
@@ -497,16 +573,25 @@ class ClaudeStructuredSession extends EventEmitter {
         prompt: this.inputQueue,
         options
       });
+      if (typeof this.query.initializationResult === 'function') {
+        await this.query.initializationResult();
+      }
+      resolveReady(this.query);
 
       for await (const message of this.query) {
         this.handleSdkMessage(message);
       }
       this.finishRunner();
+      this.sealTurns('completed');
       this.setStatus('idle');
     } catch (error) {
+      resolveReady(null);
+      const wasAborted = this.abortRequested;
+      this.inputQueue?.close();
+      this.query?.close?.();
+      this.finishRunner();
       if (!this.running) return;
-      if (this.abortRequested) {
-        this.finishRunner();
+      if (wasAborted) {
         this.setStatus('idle');
         return;
       }
@@ -515,10 +600,87 @@ class ClaudeStructuredSession extends EventEmitter {
         level: 'error',
         text: `Claude session error: ${error && error.message ? error.message : String(error)}`
       });
+      this.sealTurns('failed');
       this.setStatus('error');
     }
   }
 
+  async showUsage() {
+    try {
+      const output = await this.runLocalCommand('/usage');
+      const usage = { source: 'claude-cli-command', session: parseClaudeUsageOutput(output), fetchedAt: Date.now() };
+      this.appendMessage({ kind: 'usage', title: 'Claude usage', usage });
+      return true;
+    } catch (error) {
+      this.appendMessage({
+        kind: 'usage',
+        title: 'Claude usage',
+        error: error && error.message ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+
+  async showContext() {
+    try {
+      const output = await this.runLocalCommand('/context');
+      this.appendMessage({ kind: 'context', title: 'Claude context', context: parseClaudeContextOutput(output) });
+      return true;
+    } catch (error) {
+      this.appendMessage({
+        kind: 'context',
+        title: 'Claude context',
+        error: error && error.message ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+
+  runLocalCommand(command) {
+    const task = this.localCommandChain.then(() => this.executeLocalCommand(command));
+    this.localCommandChain = task.catch(() => {});
+    return task;
+  }
+
+  async executeLocalCommand(command) {
+    if (this.status === 'thinking') throw new Error('Wait for Claude to finish before running a local command');
+    if (this.localCommandRunner) return this.localCommandRunner(command);
+
+    const query = await this.startRunner();
+    if (!query || !this.inputQueue) throw new Error('Claude CLI session is not available');
+    if (this.pendingLocalCommand) throw new Error('Another Claude local command is already running');
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (this.pendingLocalCommand?.command !== command) return;
+        this.pendingLocalCommand = null;
+        reject(new Error(`Claude ${command} command timed out`));
+      }, LOCAL_COMMAND_TIMEOUT_MS);
+      this.pendingLocalCommand = {
+        command,
+        resolve: output => {
+          clearTimeout(timeout);
+          this.pendingLocalCommand = null;
+          resolve(output);
+        },
+        reject: error => {
+          clearTimeout(timeout);
+          this.pendingLocalCommand = null;
+          reject(error);
+        }
+      };
+      this.inputQueue.push({
+        type: 'user',
+        parent_tool_use_id: null,
+        message: { role: 'user', content: command }
+      });
+    });
+  }
+
+  rejectPendingLocalCommand(error) {
+    this.pendingLocalCommand?.reject(error);
+  }
+
   getOptionSignature() {
     return JSON.stringify({
       permissionMode: this.permissionMode,
@@ -550,6 +712,7 @@ class ClaudeStructuredSession extends EventEmitter {
       canAllowEdits: EDIT_TOOLS.has(toolName) || EXIT_PLAN_TOOLS.has(toolName),
       canBypass: EXIT_PLAN_TOOLS.has(toolName),
       input,
+      toolUseId: options.toolUseID || null,
       createdAt: Date.now(),
       status: 'pending'
     };
@@ -569,28 +732,56 @@ class ClaudeStructuredSession extends EventEmitter {
     if (!message || typeof message !== 'object') return;
 
     if (message.type === 'system' && message.subtype === 'init') {
+      const signatureBeforeInit = this.getOptionSignature();
       this.claudeSessionId = message.session_id || this.claudeSessionId;
       this.resumeSessionId = this.claudeSessionId || this.resumeSessionId;
       if (message.model) this.model = String(message.model);
-      this.appendMessage({
-        kind: 'event',
-        level: 'info',
-        text: `Claude ready${message.model ? ` (${message.model})` : ''}`
-      });
+      // Resolving runtime session/model values is not a user settings change
+      // and must not recycle the live runner after the turn.
+      if (this.activeOptionSignature === signatureBeforeInit) {
+        this.activeOptionSignature = this.getOptionSignature();
+      }
+      if (!this.runnerInitializationAnnounced) {
+        this.runnerInitializationAnnounced = true;
+        this.appendMessage({
+          kind: 'event',
+          level: 'info',
+          text: `Claude ready${message.model ? ` (${message.model})` : ''}`
+        });
+      }
       this.emitEvent({ type: 'state', state: this.getControlState() });
       return;
     }
 
+    if (message.type === 'system' && message.subtype === 'local_command_output') {
+      if (this.pendingLocalCommand) {
+        this.pendingLocalCommand.resolve(String(message.content || ''));
+      }
+      return;
+    }
+
+    if (this.pendingLocalCommand && message.type === 'assistant') return;
+
+    if (this.pendingLocalCommand && message.type === 'result') {
+      const output = typeof message.result === 'string' ? message.result : '';
+      if (message.is_error || !output) {
+        this.pendingLocalCommand.reject(new Error(output || `Claude ${this.pendingLocalCommand.command} command failed`));
+      } else {
+        this.pendingLocalCommand.resolve(output);
+      }
+      this.setStatus('idle');
+      return;
+    }
+
     if (message.type === 'assistant') {
-      const usage = message.message && message.message.usage;
-      if (usage) this.updateLatestUsageFromClaudeUsage(usage, message.message.model);
+      const turn = this.currentTurn();
       const content = message.message && message.message.content;
       const text = textFromContent(content).trim();
       const toolBlocks = Array.isArray(content)
         ? content.filter(item => item && item.type === 'tool_use')
         : [];
       if (text) {
-        this.appendMessage({ kind: 'assistant', text, raw: message });
+        this.appendMessage({ kind: 'assistant', text, raw: message, turnId: turn?.id || null });
       }
       for (const block of toolBlocks) {
         this.appendMessage({
@@ -598,7 +789,9 @@ class ClaudeStructuredSession extends EventEmitter {
           name: block.name || 'tool',
           summary: this.summarizeToolInput(block.input),
           input: block.input,
-          toolUseId: block.id
+          toolUseId: block.id,
+          turnId: turn?.id || null,
+          startedAtMs: Date.now()
         });
       }
       this.setStatus('thinking');
@@ -606,6 +799,7 @@ class ClaudeStructuredSession extends EventEmitter {
     }
 
     if (message.type === 'user') {
+      const turn = this.currentTurn();
       const content = message.message && message.message.content;
       if (Array.isArray(content)) {
         for (const item of content) {
@@ -614,7 +808,9 @@ class ClaudeStructuredSession extends EventEmitter {
               kind: 'tool-result',
               toolUseId: item.tool_use_id,
               text: textFromContent([item]).trim(),
-              isError: Boolean(item.is_error)
+              isError: Boolean(item.is_error),
+              turnId: turn?.id || null,
+              completedAtMs: Date.now()
             });
           }
         }
@@ -623,8 +819,8 @@ class ClaudeStructuredSession extends EventEmitter {
     }
 
     if (message.type === 'result') {
-      this.updateUsageFromResult(message);
-      this.setStatus('idle');
+      this.completeCurrentTurn(message.is_error || message.subtype !== 'success' ? 'failed' : 'completed', message.duration_ms);
+      this.setStatus(this.turnQueue.length > 0 ? 'thinking' : 'idle');
       if (this.inputSeq > this.completionReadInputSeq) {
         this.hasUnreadCompletion = true;
       }
@@ -635,31 +831,6 @@ class ClaudeStructuredSession extends EventEmitter {
     }
   }
 
-  updateUsageFromResult(message) {
-    const usage = message && (message.usage || message.total_usage || message.result && message.result.usage);
-    const context = usage && (usage.context_remaining || usage.contextRemaining || usage.remaining_context || usage.remainingContext);
-    this.contextRemaining = typeof context === 'number' ? context : null;
-    if (usage) this.updateLatestUsageFromClaudeUsage(usage, message.model || message.result && message.result.model);
-  }
-
-  updateLatestUsageFromClaudeUsage(usage, model = null) {
-    const inputTokens = Number(usage.input_tokens || usage.inputTokens || 0);
-    const outputTokens = Number(usage.output_tokens || usage.outputTokens || 0);
-    const cacheCreation = Number(usage.cache_creation_input_tokens || usage.cacheCreationInputTokens || 0);
-    const cacheRead = Number(usage.cache_read_input_tokens || usage.cacheReadInputTokens || 0);
-    const contextSize = inputTokens + cacheCreation + cacheRead;
-    this.latestUsage = {
-      inputTokens,
-      outputTokens,
-      cacheCreation,
-      cacheRead,
-      totalTokens: inputTokens + outputTokens + cacheCreation + cacheRead,
-      contextSize,
-      model: model || null,
-      updatedAt: Date.now()
-    };
-  }
-
   summarizeToolInput(input) {
     if (!input || typeof input !== 'object') return '';
     if (typeof input.command === 'string') return input.command;
@@ -673,6 +844,7 @@ class ClaudeStructuredSession extends EventEmitter {
     const item = this.createMessageItem(message);
     this.messages.push(item);
     this.emitEvent({ type: 'message', message: item });
+    return item;
   }
 
   setStatus(status) {