glad-web 1.0.20 → 1.0.22

package/README.md

@@ -63,7 +63,7 @@ Requirements:
 - Node.js `>=18`
 
 ```bash
-git clone https://github.com/Next2012/Glad.git
+git clone https://github.com/Anonymous/Glad.git
 cd glad
 npm install
 node bin/cli.js
@@ -192,4 +192,4 @@ See [SECURITY.md](./SECURITY.md) for details.
 
 ## License
 
-MIT. Glad is maintained by [next2012](https://github.com/Next2012/Glad).
+MIT. Glad is maintained by [anonymous](https://github.com/Anonymous/Glad).

package/README.zh-CN.md

@@ -63,7 +63,7 @@ glad
 - Node.js `>=18`
 
 ```bash
-git clone https://github.com/Next2012/Glad.git
+git clone https://github.com/Anonymous/Glad.git
 cd glad
 npm install
 node bin/cli.js
@@ -192,4 +192,4 @@ Glad 面向受信任的本机或局域网环境使用。
 
 ## 开源协议
 
-本项目使用 MIT 协议，由 [next2012](https://github.com/Next2012/Glad) 维护。
+本项目使用 MIT 协议，由 [anonymous](https://github.com/Anonymous/Glad) 维护。

package/bin/cli.js

@@ -57,7 +57,7 @@ program.on('--help', () => {
   console.log('Supported AI Tools:');
   console.log('  • Claude Code, Aider, GitHub Copilot, Gemini CLI, and more...');
   console.log('');
-  console.log('Source: https://gitee.com/next2012/glad');
+  console.log('Source: https://gitee.com/anonymous/glad');
   console.log('');
 });
 

package/lib/ai-tools/registry.js

@@ -200,7 +200,7 @@ const AI_TOOLS = {
     args: [require('path').join(__dirname, 'demo', 'index.js')],
     displayName: 'Demo',
     description: 'Interactive demo for testing (no AI installation required)',
-    website: 'https://gitee.com/next2012/glad',
+    website: 'https://gitee.com/anonymous/glad',
     checkInstalled: async () => true // Always available
   }
 };

package/lib/claude/structured-session.js

@@ -3,6 +3,9 @@ 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');
@@ -88,10 +91,14 @@ class ClaudeStructuredSession extends EventEmitter {
     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 = {
@@ -140,6 +147,7 @@ class ClaudeStructuredSession extends EventEmitter {
       claudeSessionId: this.claudeSessionId || null,
       resumeSessionId: this.resumeSessionId || null,
       contextRemaining: this.contextRemaining,
+      latestUsage: this.latestUsage,
       canAbort: this.status === 'thinking',
       pendingPermissionCount: this.pendingPermissions.size
     };
@@ -238,7 +246,7 @@ class ClaudeStructuredSession extends EventEmitter {
 
     if (changed) {
       if (this.query && typeof this.query.setPermissionMode === 'function') {
-        Promise.resolve(this.query.setPermissionMode(this.permissionMode)).catch(error => {
+        Promise.resolve(this.query.setPermissionMode(this.getSdkPermissionMode())).catch(error => {
           this.logger.debugInfo?.(`[claude-structured] setPermissionMode failed: ${error.message}`);
         });
       }
@@ -298,18 +306,161 @@ class ClaudeStructuredSession extends EventEmitter {
     this.abortController = null;
   }
 
-  respondPermission(id, approved) {
+  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 publicRequest = { ...pending.public, status: approved ? 'approved' : 'denied' };
+    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', toolUseID: pending.toolUseID, decisionClassification: 'user_temporary' }
-      : { behavior: 'deny', message: 'Denied by user', interrupt: true, toolUseID: pending.toolUseID, decisionClassification: 'user_reject' });
+      ? {
+          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;
@@ -330,7 +481,8 @@ class ClaudeStructuredSession extends EventEmitter {
       const options = {
         cwd: this.workingDir,
         resume: this.resumeSessionId || undefined,
-        permissionMode: this.permissionMode,
+        permissionMode: this.getSdkPermissionMode(),
+        allowDangerouslySkipPermissions: false,
         effort: this.effort,
         tools: { type: 'preset', preset: 'claude_code' },
         env: {
@@ -349,10 +501,12 @@ class ClaudeStructuredSession extends EventEmitter {
       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;
       }
@@ -375,12 +529,26 @@ class ClaudeStructuredSession extends EventEmitter {
   }
 
   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`,
-      reason: options.decisionReason || '',
+      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'
@@ -390,6 +558,8 @@ class ClaudeStructuredSession extends EventEmitter {
       this.pendingPermissions.set(id, {
         public: request,
         resolve,
+        input,
+        toolName,
         toolUseID: options.toolUseID
       });
     });
@@ -412,6 +582,8 @@ class ClaudeStructuredSession extends EventEmitter {
     }
 
     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)
@@ -467,6 +639,25 @@ class ClaudeStructuredSession extends EventEmitter {
     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) {