glad-web 1.0.19 → 1.0.21

package/lib/claude/structured-session.js

@@ -0,0 +1,707 @@
+const { EventEmitter } = require('events');
+const crypto = require('crypto');
+const { normalizeEffort, normalizeModel, resolveClaudeModel } = require('./config');
+
+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.";
+
+function normalizePermissionMode(value) {
+  const mode = String(value || 'default');
+  return PERMISSION_MODES.has(mode) ? mode : 'default';
+}
+
+function textFromContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map(item => {
+      if (!item || typeof item !== 'object') return '';
+      if (item.type === 'text' && typeof item.text === 'string') return item.text;
+      if (item.type === 'tool_result') {
+        if (typeof item.content === 'string') return item.content;
+        if (Array.isArray(item.content)) return textFromContent(item.content);
+      }
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+class AsyncMessageQueue {
+  constructor() {
+    this.items = [];
+    this.waiters = [];
+    this.closed = false;
+  }
+
+  push(item) {
+    if (this.closed) return false;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter({ value: item, done: false });
+    else this.items.push(item);
+    return true;
+  }
+
+  close() {
+    this.closed = true;
+    while (this.waiters.length > 0) {
+      this.waiters.shift()({ value: undefined, done: true });
+    }
+  }
+
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.items.length > 0) {
+          return Promise.resolve({ value: this.items.shift(), done: false });
+        }
+        if (this.closed) return Promise.resolve({ value: undefined, done: true });
+        return new Promise(resolve => this.waiters.push(resolve));
+      }
+    };
+  }
+}
+
+class ClaudeStructuredSession extends EventEmitter {
+  constructor({ id, tool, workingDir, name, logger, options = {} }) {
+    super();
+    this.id = id;
+    this.tool = tool;
+    this.name = name || tool.displayName;
+    this.workingDir = workingDir;
+    this.logger = logger || console;
+    this.kind = 'claude-structured';
+    this.startTime = Date.now();
+    this.running = true;
+    this.status = 'idle';
+    this.messages = [];
+    this.pendingPermissions = new Map();
+    this.pendingInput = '';
+    this.inputSeq = 0;
+    this.hasUnreadCompletion = false;
+    this.completionReadInputSeq = 0;
+    this.timedInputs = new Map();
+    this.abortController = null;
+    this.inputQueue = null;
+    this.query = null;
+    this.runnerStarted = false;
+    this.abortRequested = false;
+    this.permissionMode = normalizePermissionMode(options.permissionMode);
+    this.model = normalizeModel(options.model);
+    this.effort = normalizeEffort(options.effort);
+    this.allowedTools = new Set();
+    this.allowedBashLiterals = new Set();
+    this.allowedBashPrefixes = new Set();
+    this.resumeSessionId = options.resume || null;
+    this.claudeSessionId = options.resume || null;
+    this.activeOptionSignature = null;
+    this.contextRemaining = null;
+    this.latestUsage = null;
+
+    // Compatibility with existing session-scoped Git/file APIs.
+    this.ptyManager = {
+      workingDir,
+      isRunning: () => this.isRunning(),
+      write: data => this.write(data),
+      kill: () => this.kill(),
+      resize: () => {},
+      redraw: () => false
+    };
+  }
+
+  toListItem() {
+    return {
+      id: this.id,
+      name: this.name,
+      tool: this.tool.displayName,
+      startTime: this.startTime,
+      toolKey: this.tool.key,
+      workingDirectory: this.workingDir,
+      hasUnreadCompletion: Boolean(this.hasUnreadCompletion),
+      timedInputCount: Array.from(this.timedInputs.values()).filter(item => item.sendAt > Date.now()).length,
+      mode: 'structured'
+    };
+  }
+
+  snapshot() {
+    return {
+      id: this.id,
+      name: this.name,
+      tool: this.tool.displayName,
+      toolKey: this.tool.key,
+      status: this.status,
+      state: this.getControlState(),
+      messages: this.messages,
+      pendingPermissions: Array.from(this.pendingPermissions.values()).map(item => item.public)
+    };
+  }
+
+  getControlState() {
+    return {
+      permissionMode: this.permissionMode,
+      model: this.model,
+      effort: this.effort,
+      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
+    };
+  }
+
+  getHistory() {
+    const lines = [];
+    for (const message of this.messages) {
+      if (message.kind === 'user') lines.push(`User: ${message.text}`);
+      if (message.kind === 'assistant') lines.push(`Claude: ${message.text}`);
+      if (message.kind === 'tool') lines.push(`Tool ${message.name}: ${message.summary}`);
+      if (message.kind === 'event') lines.push(message.text);
+    }
+    const text = lines.join('\n\n');
+    return {
+      success: true,
+      sessionId: this.id,
+      sessionName: this.name,
+      tool: this.tool.displayName,
+      historyMode: 'structured',
+      text,
+      updatedAt: Date.now(),
+      truncated: false,
+      bytes: Buffer.byteLength(text, 'utf8'),
+      lines: text ? text.split('\n').length : 0
+    };
+  }
+
+  getCatchupOutput() {
+    return {
+      source: 'claude-structured',
+      items: this.messages.length,
+      data: ''
+    };
+  }
+
+  write(data) {
+    if (!this.running) return false;
+    const text = String(data || '');
+    if (!text) return true;
+
+    this.pendingInput += text.replace(/\r/g, '\n');
+    if (!this.pendingInput.includes('\n')) return true;
+
+    const parts = this.pendingInput.split('\n');
+    this.pendingInput = parts.pop() || '';
+    const prompt = parts.join('\n').trim();
+    if (prompt) this.sendUserMessage(prompt);
+    return true;
+  }
+
+  sendUserMessage(text) {
+    if (!this.running) return false;
+    const prompt = String(text || '').trim();
+    if (!prompt) return false;
+    this.hasUnreadCompletion = false;
+    this.appendMessage({ kind: 'user', text: prompt });
+
+    const sdkMessage = {
+      type: 'user',
+      parent_tool_use_id: null,
+      message: {
+        role: 'user',
+        content: prompt
+      }
+    };
+
+    if (!this.runnerStarted) {
+      this.startRunner(sdkMessage);
+    } else if (this.inputQueue) {
+      this.inputQueue.push(sdkMessage);
+    }
+    return true;
+  }
+
+  createMessageItem(message) {
+    return {
+      id: crypto.randomUUID(),
+      createdAt: Date.now(),
+      ...message
+    };
+  }
+
+  updateSettings(settings = {}) {
+    const next = {
+      permissionMode: settings.permissionMode === undefined ? this.permissionMode : normalizePermissionMode(settings.permissionMode),
+      model: settings.model === undefined ? this.model : normalizeModel(settings.model),
+      effort: settings.effort === undefined ? this.effort : normalizeEffort(settings.effort)
+    };
+    const changed = next.permissionMode !== this.permissionMode
+      || next.model !== this.model
+      || next.effort !== this.effort;
+    this.permissionMode = next.permissionMode;
+    this.model = next.model;
+    this.effort = next.effort;
+
+    if (changed) {
+      if (this.query && typeof this.query.setPermissionMode === 'function') {
+        Promise.resolve(this.query.setPermissionMode(this.getSdkPermissionMode())).catch(error => {
+          this.logger.debugInfo?.(`[claude-structured] setPermissionMode failed: ${error.message}`);
+        });
+      }
+      if (this.runnerStarted && this.status === 'idle' && this.activeOptionSignature !== this.getOptionSignature()) {
+        this.resetRunnerForNextTurn();
+      }
+      this.emitEvent({ type: 'state', state: this.getControlState() });
+    }
+    return this.getControlState();
+  }
+
+  selectResumeSession(resumeSessionId, historyMessages = null) {
+    const id = String(resumeSessionId || '').trim();
+    if (!id) return false;
+    if (this.status === 'thinking') this.abort('Switching resume target');
+    this.resumeSessionId = id;
+    this.claudeSessionId = id;
+    this.resetRunnerForNextTurn();
+    const eventMessage = this.createMessageItem({
+      kind: 'event',
+      level: 'info',
+      text: `Resume target selected: ${id}`
+    });
+    if (Array.isArray(historyMessages)) {
+      this.messages = [...historyMessages, eventMessage];
+      this.emitEvent({ type: 'history-reset', messages: this.messages });
+    } else {
+      this.messages.push(eventMessage);
+      this.emitEvent({ type: 'message', message: eventMessage });
+    }
+    this.emitEvent({ type: 'state', state: this.getControlState() });
+    return true;
+  }
+
+  abort(reason = 'Aborted by user') {
+    if (!this.runnerStarted && this.status !== 'thinking') return false;
+    this.abortRequested = true;
+    this.inputQueue?.close();
+    this.query?.close?.();
+    this.abortController?.abort();
+    this.runnerStarted = false;
+    this.inputQueue = null;
+    this.query = null;
+    this.abortController = null;
+    this.setStatus('idle');
+    this.appendMessage({ kind: 'event', level: 'info', text: reason });
+    this.emitEvent({ type: 'state', state: this.getControlState() });
+    return true;
+  }
+
+  resetRunnerForNextTurn() {
+    this.inputQueue?.close();
+    this.query?.close?.();
+    this.runnerStarted = false;
+    this.inputQueue = null;
+    this.query = null;
+    this.abortController = null;
+  }
+
+  finishRunner() {
+    this.runnerStarted = false;
+    this.inputQueue?.close();
+    this.inputQueue = null;
+    this.query = null;
+    this.abortController = null;
+  }
+
+  respondPermission(id, approved, action = null) {
+    const pending = this.pendingPermissions.get(id);
+    if (!pending) return false;
+    this.pendingPermissions.delete(id);
+    const normalizedAction = this.normalizePermissionAction(action, approved);
+    const allowedTools = this.getAllowedToolsForAction(normalizedAction, pending);
+    const nextMode = this.getPermissionModeForAction(normalizedAction);
+    if (allowedTools.length > 0) this.addAllowedTools(allowedTools);
+    if (nextMode) {
+      this.permissionMode = nextMode;
+      if (this.query && typeof this.query.setPermissionMode === 'function') {
+        Promise.resolve(this.query.setPermissionMode(this.getSdkPermissionMode())).catch(error => {
+          this.logger.debugInfo?.(`[claude-structured] setPermissionMode failed: ${error.message}`);
+        });
+      }
+    }
+    const publicRequest = {
+      ...pending.public,
+      status: approved ? 'approved' : 'denied',
+      action: normalizedAction,
+      mode: nextMode || undefined,
+      allowedTools: allowedTools.length > 0 ? allowedTools : undefined
+    };
+    this.emitEvent({ type: 'permission-updated', request: publicRequest });
+    pending.resolve(approved
+      ? {
+          behavior: 'allow',
+          updatedInput: pending.input || {},
+          updatedPermissions: this.getPermissionUpdatesForAction(normalizedAction, pending),
+          toolUseID: pending.toolUseID,
+          decisionClassification: normalizedAction === 'allow-once' ? 'user_temporary' : 'user_permanent'
+        }
+      : { behavior: 'deny', message: DENY_PERMISSION_MESSAGE, interrupt: true, toolUseID: pending.toolUseID, decisionClassification: 'user_reject' });
+    this.emitEvent({ type: 'state', state: this.getControlState() });
+    return true;
+  }
+
+  normalizePermissionAction(action, approved) {
+    if (!approved) return 'deny';
+    const value = String(action || '').trim();
+    if (['allow-once', 'allow-tool', 'allow-edits', 'bypass'].includes(value)) return value;
+    return 'allow-once';
+  }
+
+  getPermissionModeForAction(action) {
+    if (action === 'allow-edits') return 'acceptEdits';
+    if (action === 'bypass') return 'bypassPermissions';
+    return null;
+  }
+
+  getSdkPermissionMode() {
+    // Claude CLI refuses --dangerously-skip-permissions under root/sudo. Glad
+    // keeps bypass as local state and auto-allows through canUseTool instead.
+    if (this.permissionMode === 'bypassPermissions') return 'default';
+    return this.permissionMode;
+  }
+
+  getAllowedToolsForAction(action, pending) {
+    if (action !== 'allow-tool') return [];
+    const toolName = pending.toolName || pending.public.toolName;
+    if (!toolName) return [];
+    if (toolName === 'Bash') {
+      const command = pending.input && typeof pending.input.command === 'string'
+        ? pending.input.command
+        : '';
+      return command ? [`Bash(${command})`] : ['Bash'];
+    }
+    return [toolName];
+  }
+
+  getPermissionUpdatesForAction(action, pending) {
+    const mode = this.getPermissionModeForAction(action);
+    const allowedTools = this.getAllowedToolsForAction(action, pending);
+    const updates = [];
+    if (allowedTools.length > 0) {
+      updates.push({
+        type: 'addRules',
+        rules: allowedTools.map(tool => this.permissionRuleFromTool(tool)),
+        behavior: 'allow',
+        destination: 'session'
+      });
+    }
+    if (mode === 'acceptEdits') {
+      updates.push({
+        type: 'addRules',
+        rules: Array.from(EDIT_TOOLS).map(toolName => ({ toolName })),
+        behavior: 'allow',
+        destination: 'session'
+      });
+    }
+    return updates.length > 0 ? updates : undefined;
+  }
+
+  permissionRuleFromTool(tool) {
+    const match = String(tool || '').match(/^Bash\(([\s\S]*)\)$/);
+    if (match) return { toolName: 'Bash', ruleContent: match[1] };
+    return { toolName: String(tool || '') };
+  }
+
+  addAllowedTools(tools) {
+    for (const tool of tools) {
+      if (tool === 'Bash') {
+        this.allowedTools.add(tool);
+      } else if (tool.startsWith('Bash(')) {
+        this.parseBashPermission(tool);
+      } else {
+        this.allowedTools.add(tool);
+      }
+    }
+  }
+
+  parseBashPermission(permission) {
+    const match = String(permission || '').match(/^Bash\(([\s\S]*)\)$/);
+    if (!match) return;
+    const command = match[1];
+    if (command.endsWith(':*')) {
+      this.allowedBashPrefixes.add(command.slice(0, -2));
+    } else {
+      this.allowedBashLiterals.add(command);
+    }
+  }
+
+  isToolAllowed(toolName, input) {
+    if (toolName === 'Bash') {
+      if (this.allowedTools.has('Bash')) return true;
+      const command = input && typeof input.command === 'string' ? input.command : '';
+      if (command && this.allowedBashLiterals.has(command)) return true;
+      for (const prefix of this.allowedBashPrefixes) {
+        if (command.startsWith(prefix)) return true;
+      }
+      return false;
+    }
+    return this.allowedTools.has(toolName);
+  }
+
+  shouldAutoAllowTool(toolName, input) {
+    if (this.isToolAllowed(toolName, input)) return true;
+    if (this.permissionMode === 'bypassPermissions' && !EXIT_PLAN_TOOLS.has(toolName)) return true;
+    if (this.permissionMode === 'acceptEdits' && EDIT_TOOLS.has(toolName)) return true;
+    if (this.permissionMode === 'plan' && !this.isDangerousTool(toolName)) return true;
+    return false;
+  }
+
+  isDangerousTool(toolName) {
+    return toolName === 'Bash' || EDIT_TOOLS.has(toolName) || EXIT_PLAN_TOOLS.has(toolName);
+  }
+
+  markCompletionRead() {
+    this.hasUnreadCompletion = false;
+    this.completionReadInputSeq = this.inputSeq || 0;
+  }
+
+  async startRunner(initialMessage) {
+    this.runnerStarted = true;
+    this.inputQueue = new AsyncMessageQueue();
+    this.inputQueue.push(initialMessage);
+    this.abortController = new AbortController();
+    this.abortRequested = false;
+    this.activeOptionSignature = this.getOptionSignature();
+    this.setStatus('thinking');
+
+    try {
+      const sdk = await import('@anthropic-ai/claude-agent-sdk');
+      const resolvedModel = resolveClaudeModel(this.model, process.env);
+      const options = {
+        cwd: this.workingDir,
+        resume: this.resumeSessionId || undefined,
+        permissionMode: this.getSdkPermissionMode(),
+        allowDangerouslySkipPermissions: false,
+        effort: this.effort,
+        tools: { type: 'preset', preset: 'claude_code' },
+        env: {
+          ...process.env,
+          CLAUDE_AGENT_SDK_CLIENT_APP: 'glad-web'
+        },
+        abortController: this.abortController,
+        canUseTool: (toolName, input, options) => this.requestPermission(toolName, input, options)
+      };
+      if (resolvedModel) options.model = resolvedModel;
+      this.query = sdk.query({
+        prompt: this.inputQueue,
+        options
+      });
+
+      for await (const message of this.query) {
+        this.handleSdkMessage(message);
+      }
+      this.finishRunner();
+      this.setStatus('idle');
+    } catch (error) {
+      if (!this.running) return;
+      if (this.abortRequested) {
+        this.finishRunner();
+        this.setStatus('idle');
+        return;
+      }
+      this.appendMessage({
+        kind: 'event',
+        level: 'error',
+        text: `Claude session error: ${error && error.message ? error.message : String(error)}`
+      });
+      this.setStatus('error');
+    }
+  }
+
+  getOptionSignature() {
+    return JSON.stringify({
+      permissionMode: this.permissionMode,
+      model: this.model,
+      effort: this.effort,
+      resume: this.resumeSessionId || null
+    });
+  }
+
+  requestPermission(toolName, input, options = {}) {
+    if (toolName !== 'AskUserQuestion' && this.shouldAutoAllowTool(toolName, input)) {
+      return Promise.resolve({
+        behavior: 'allow',
+        updatedInput: input || {},
+        toolUseID: options.toolUseID,
+        decisionClassification: 'user_permanent'
+      });
+    }
+    const id = crypto.randomUUID();
+    const request = {
+      id,
+      toolName,
+      title: options.title || `${toolName} requires approval`,
+      displayName: options.displayName || '',
+      description: options.description || '',
+      reason: options.decisionReason || options.description || '',
+      blockedPath: options.blockedPath || null,
+      canAllowTool: Boolean(toolName && !EDIT_TOOLS.has(toolName) && !EXIT_PLAN_TOOLS.has(toolName)),
+      canAllowEdits: EDIT_TOOLS.has(toolName) || EXIT_PLAN_TOOLS.has(toolName),
+      canBypass: EXIT_PLAN_TOOLS.has(toolName),
+      input,
+      createdAt: Date.now(),
+      status: 'pending'
+    };
+    this.emitEvent({ type: 'permission-request', request });
+    return new Promise(resolve => {
+      this.pendingPermissions.set(id, {
+        public: request,
+        resolve,
+        input,
+        toolName,
+        toolUseID: options.toolUseID
+      });
+    });
+  }
+
+  handleSdkMessage(message) {
+    if (!message || typeof message !== 'object') return;
+
+    if (message.type === 'system' && message.subtype === 'init') {
+      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})` : ''}`
+      });
+      this.emitEvent({ type: 'state', state: this.getControlState() });
+      return;
+    }
+
+    if (message.type === 'assistant') {
+      const usage = message.message && message.message.usage;
+      if (usage) this.updateLatestUsageFromClaudeUsage(usage, message.message.model);
+      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 });
+      }
+      for (const block of toolBlocks) {
+        this.appendMessage({
+          kind: 'tool',
+          name: block.name || 'tool',
+          summary: this.summarizeToolInput(block.input),
+          input: block.input,
+          toolUseId: block.id
+        });
+      }
+      this.setStatus('thinking');
+      return;
+    }
+
+    if (message.type === 'user') {
+      const content = message.message && message.message.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item && item.type === 'tool_result') {
+            this.appendMessage({
+              kind: 'tool-result',
+              toolUseId: item.tool_use_id,
+              text: textFromContent([item]).trim(),
+              isError: Boolean(item.is_error)
+            });
+          }
+        }
+      }
+      return;
+    }
+
+    if (message.type === 'result') {
+      this.updateUsageFromResult(message);
+      this.setStatus('idle');
+      if (this.inputSeq > this.completionReadInputSeq) {
+        this.hasUnreadCompletion = true;
+      }
+      this.emit('complete');
+      if (this.activeOptionSignature !== this.getOptionSignature()) {
+        this.resetRunnerForNextTurn();
+      }
+    }
+  }
+
+  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;
+    if (typeof input.file_path === 'string') return input.file_path;
+    if (typeof input.path === 'string') return input.path;
+    const serialized = JSON.stringify(input);
+    return serialized.length > 240 ? serialized.slice(0, 240) + '...' : serialized;
+  }
+
+  appendMessage(message) {
+    const item = this.createMessageItem(message);
+    this.messages.push(item);
+    this.emitEvent({ type: 'message', message: item });
+  }
+
+  setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    this.emitEvent({ type: 'status', status });
+    this.emitEvent({ type: 'state', state: this.getControlState() });
+  }
+
+  emitEvent(event) {
+    this.emit('event', event);
+  }
+
+  isRunning() {
+    return this.running;
+  }
+
+  kill() {
+    this.running = false;
+    this.inputQueue?.close();
+    this.query?.close?.();
+    this.abortController?.abort();
+    for (const pending of this.pendingPermissions.values()) {
+      pending.resolve({ behavior: 'deny', message: 'Session ended', interrupt: true, toolUseID: pending.toolUseID });
+    }
+    this.pendingPermissions.clear();
+    this.setStatus('stopped');
+    this.emit('exit', { exitCode: 0 });
+  }
+}
+
+module.exports = ClaudeStructuredSession;