aegiscode 3.1.8 → 3.1.10

package/src/tools/validation/PermissionChecker.ts

@@ -0,0 +1,242 @@
+/**
+ * 
+ * 
+ */
+
+import { minimatch } from 'minimatch';
+import {
+  PermissionResult,
+  type PermissionCheckResult,
+  type PermissionConfig,
+  type ToolInvocationDescriptor,
+} from '../execution/types.js';
+
+/**
+ * 
+ */
+export const DEFAULT_PERMISSION_CONFIG: PermissionConfig = {
+  allow: [
+    // 只读工具默认允
+    'Read(**/*)',
+    'Glob(**/*)',
+    'Grep(**/*)',
+  ],
+  deny: [
+    // 危险命令默认拒
+    'Bash(rm -rf:*)',
+    'Bash(sudo:*)',
+    'Write(/etc/*)',
+    'Write(/usr/*)',
+    'Write(/System/*)',
+  ],
+  ask: [],
+};
+
+/**
+ * 
+ */
+export class PermissionChecker {
+  private config: PermissionConfig;
+
+  constructor(config?: Partial<PermissionConfig>) {
+    this.config = {
+      allow: [...DEFAULT_PERMISSION_CONFIG.allow, ...(config?.allow || [])],
+      deny: [...DEFAULT_PERMISSION_CONFIG.deny, ...(config?.deny || [])],
+      ask: [...DEFAULT_PERMISSION_CONFIG.ask, ...(config?.ask || [])],
+    };
+  }
+
+  /**
+   * 
+   */
+  check(descriptor: ToolInvocationDescriptor): PermissionCheckResult {
+    const signature = PermissionChecker.buildSignature(descriptor);
+
+    // 1. 检查 deny 规则（优先级最
+    for (const rule of this.config.deny) {
+      if (this.matchesRule(signature, rule, descriptor)) {
+        return {
+          result: PermissionResult.DENY,
+          matchedRule: rule,
+          reason: `Not executed: rule "${rule}" excludes this action. Choose a different approach.`,
+        };
+      }
+    }
+
+    // 2. 检查 allow 规
+    for (const rule of this.config.allow) {
+      if (this.matchesRule(signature, rule, descriptor)) {
+        return {
+          result: PermissionResult.ALLOW,
+          matchedRule: rule,
+          reason: `Allowed by rule: ${rule}`,
+        };
+      }
+    }
+
+    // 3. 检查 ask 规
+    for (const rule of this.config.ask) {
+      if (this.matchesRule(signature, rule, descriptor)) {
+        return {
+          result: PermissionResult.ASK,
+          matchedRule: rule,
+          reason: `Requires confirmation by rule: ${rule}`,
+        };
+      }
+    }
+
+    // 4. 默
+    return {
+      result: PermissionResult.ASK,
+      matchedRule: 'default',
+      reason: 'No matching rule, requires confirmation',
+    };
+  }
+
+  /**
+   * 
+   */
+  static buildSignature(descriptor: ToolInvocationDescriptor): string {
+    const { toolName, params, tool } = descriptor;
+
+    // 使用工具的 extractSignatureContent 方法（如果存
+    if (tool?.extractSignatureContent) {
+      const content = tool.extractSignatureContent(params);
+      return `${toolName}(${content})`;
+    }
+
+    // 如果没有工具对象，尝试从常见参数提取签名内
+    const signatureContent = PermissionChecker.extractDefaultSignatureContent(toolName, params);
+    if (signatureContent) {
+      return `${toolName}(${signatureContent})`;
+    }
+
+    // 默认：只返回工具
+    return toolName;
+  }
+
+  /**
+   * 
+   */
+  private static extractDefaultSignatureContent(
+    toolName: string,
+    params: Record<string, unknown>
+  ): string | null {
+    switch (toolName) {
+      case 'Bash':
+        if (typeof params.command === 'string') {
+          return params.command;
+        }
+        break;
+      case 'Read':
+      case 'Write':
+      case 'Edit':
+        if (typeof params.file_path === 'string') {
+          return params.file_path;
+        }
+        break;
+      case 'Glob':
+        if (typeof params.pattern === 'string') {
+          return params.pattern;
+        }
+        break;
+      case 'Grep':
+        if (typeof params.pattern === 'string') {
+          return params.pattern;
+        }
+        break;
+    }
+    return null;
+  }
+
+  /**
+   * 
+   */
+  private matchesRule(
+    signature: string,
+    rule: string,
+    descriptor: ToolInvocationDescriptor
+  ): boolean {
+    // 1. 精确匹配工具
+    if (rule === descriptor.toolName) {
+      return true;
+    }
+
+    // 2. 解析规
+    const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
+    if (!match) {
+      return false;
+    }
+
+    const [, ruleTool, rulePattern] = match;
+
+    // 工具名不匹
+    if (ruleTool !== descriptor.toolName) {
+      return false;
+    }
+
+    // 没有参数模式，匹配所有该工具的调
+    if (!rulePattern) {
+      return true;
+    }
+
+    // 3. 提取签名内
+    const signatureContent = this.extractSignatureContent(signature);
+
+    // 4. 匹配模
+    return this.matchPattern(signatureContent, rulePattern);
+  }
+
+  /**
+   * 
+   */
+  private extractSignatureContent(signature: string): string {
+    const match = signature.match(/^\w+\((.+)\)$/);
+    return match ? match[1] : '';
+  }
+
+  /**
+   * 
+   */
+  private matchPattern(content: string, pattern: string): boolean {
+    // 1. 前缀通配符 (npm:* 
+    if (pattern.endsWith(':*')) {
+      const prefix = pattern.slice(0, -2);
+      return content.startsWith(prefix);
+    }
+
+    // 2. Glob 模
+    if (pattern.includes('*') || pattern.includes('?')) {
+      return minimatch(content, pattern, { dot: true });
+    }
+
+    // 3. 精确匹
+    return content === pattern;
+  }
+
+  /**
+   * 
+   */
+  addRule(type: 'allow' | 'deny' | 'ask', rule: string): void {
+    this.config[type].push(rule);
+  }
+
+  /**
+   * 
+   */
+  removeRule(type: 'allow' | 'deny' | 'ask', rule: string): boolean {
+    const index = this.config[type].indexOf(rule);
+    if (index !== -1) {
+      this.config[type].splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 
+   */
+  getConfig(): PermissionConfig {
+    return { ...this.config };
+  }
+}

package/src/tools/validation/SensitiveFileDetector.ts

@@ -0,0 +1,210 @@
+/**
+ * 
+ * 
+ */
+
+// ========== 敏感级
+
+/**
+ * 
+ */
+export enum SensitivityLevel {
+  /** 低敏感：配置文件 */
+  LOW = 'low',
+  /** 中敏感：数据库、日志 */
+  MEDIUM = 'medium',
+  /** 高敏感：密钥、凭证 */
+  HIGH = 'high',
+}
+
+// ========== 检测结
+
+/**
+ * 
+ */
+export interface SensitivityResult {
+  sensitive: boolean;
+  level?: SensitivityLevel;
+  reason?: string;
+}
+
+/**
+ * 
+ */
+export interface SensitivityResultWithPath {
+  path: string;
+  result: SensitivityResult;
+}
+
+// ========== 敏感规
+
+/**
+ * 
+ */
+interface SensitiveRule {
+  pattern: RegExp;
+  level: SensitivityLevel;
+  reason: string;
+}
+
+// ========== 检测
+
+/**
+ * 
+ */
+export class SensitiveFileDetector {
+  /**
+   * 
+   */
+  private static readonly SENSITIVE_PATTERNS: SensitiveRule[] = [
+    // ========== 高敏
+    // 环境变
+    { pattern: /\.env$/, level: SensitivityLevel.HIGH, reason: '环境变量文件可能包含密钥' },
+    { pattern: /\.env\.(local|development|production|test)$/, level: SensitivityLevel.HIGH, reason: '环境变量文件可能包含密钥' },
+
+    // 凭证文
+    { pattern: /credentials?\.json$/, level: SensitivityLevel.HIGH, reason: '凭证文件' },
+    { pattern: /secrets?\.json$/, level: SensitivityLevel.HIGH, reason: '密钥文件' },
+    { pattern: /\.credentials$/, level: SensitivityLevel.HIGH, reason: '凭证文件' },
+
+    // 密钥文
+    { pattern: /\.pem$/, level: SensitivityLevel.HIGH, reason: '私钥/证书文件' },
+    { pattern: /\.key$/, level: SensitivityLevel.HIGH, reason: '密钥文件' },
+    { pattern: /\.p12$/, level: SensitivityLevel.HIGH, reason: 'PKCS12 证书文件' },
+    { pattern: /\.pfx$/, level: SensitivityLevel.HIGH, reason: 'PFX 证书文件' },
+
+    // SSH 密
+    { pattern: /id_rsa/, level: SensitivityLevel.HIGH, reason: 'SSH RSA 私钥' },
+    { pattern: /id_ed25519/, level: SensitivityLevel.HIGH, reason: 'SSH Ed25519 私钥' },
+    { pattern: /id_ecdsa/, level: SensitivityLevel.HIGH, reason: 'SSH ECDSA 私钥' },
+    { pattern: /id_dsa/, level: SensitivityLevel.HIGH, reason: 'SSH DSA 私钥' },
+
+    // AWS
+    { pattern: /\.aws\/credentials$/, level: SensitivityLevel.HIGH, reason: 'AWS 凭证文件' },
+
+    // 其
+    { pattern: /\.htpasswd$/, level: SensitivityLevel.HIGH, reason: 'HTTP 密码文件' },
+    { pattern: /\.netrc$/, level: SensitivityLevel.HIGH, reason: '网络凭证文件' },
+
+    // ========== 中敏
+    // 数据
+    { pattern: /\.sqlite3?$/, level: SensitivityLevel.MEDIUM, reason: 'SQLite 数据库文件' },
+    { pattern: /\.db$/, level: SensitivityLevel.MEDIUM, reason: '数据库文件' },
+
+    // 日
+    { pattern: /\.log$/, level: SensitivityLevel.MEDIUM, reason: '日志文件可能包含敏感信息' },
+
+    // 历史记
+    { pattern: /\.bash_history$/, level: SensitivityLevel.MEDIUM, reason: 'Bash 历史记录' },
+    { pattern: /\.zsh_history$/, level: SensitivityLevel.MEDIUM, reason: 'Zsh 历史记录' },
+
+    // 其他配
+    { pattern: /\.npmrc$/, level: SensitivityLevel.MEDIUM, reason: 'npm 配置可能包含 token' },
+    { pattern: /\.pypirc$/, level: SensitivityLevel.MEDIUM, reason: 'PyPI 配置可能包含 token' },
+
+    // ========== 低敏
+    // 配置文
+    { pattern: /config\.json$/, level: SensitivityLevel.LOW, reason: '配置文件' },
+    { pattern: /settings\.json$/, level: SensitivityLevel.LOW, reason: '设置文件' },
+    { pattern: /\.gitconfig$/, level: SensitivityLevel.LOW, reason: 'Git 配置文件' },
+  ];
+
+  /**
+   * 
+   */
+  private static readonly DANGEROUS_PATHS: RegExp[] = [
+    /^\/etc\//,
+    /^\/usr\//,
+    /^\/System\//,
+    /^\/var\//,
+    /^\/root\//,
+    /^C:\\Windows\\/i,
+    /^C:\\Program Files/i,
+  ];
+
+  /**
+   * 
+   */
+  static check(filePath: string): SensitivityResult {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+
+    for (const rule of this.SENSITIVE_PATTERNS) {
+      if (rule.pattern.test(normalizedPath)) {
+        return {
+          sensitive: true,
+          level: rule.level,
+          reason: rule.reason,
+        };
+      }
+    }
+
+    return { sensitive: false };
+  }
+
+  /**
+   * 
+   */
+  static isDangerousPath(filePath: string): boolean {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    return this.DANGEROUS_PATHS.some(pattern => pattern.test(normalizedPath));
+  }
+
+  /**
+   * 
+   */
+  static checkMultiple(filePaths: string[]): SensitivityResultWithPath[] {
+    return filePaths.map(path => ({
+      path,
+      result: this.check(path),
+    }));
+  }
+
+  /**
+   * 
+   */
+  static filterSensitive(
+    filePaths: string[],
+    minLevel: SensitivityLevel = SensitivityLevel.LOW
+  ): SensitivityResultWithPath[] {
+    const levelOrder = {
+      [SensitivityLevel.LOW]: 0,
+      [SensitivityLevel.MEDIUM]: 1,
+      [SensitivityLevel.HIGH]: 2,
+    };
+
+    return this.checkMultiple(filePaths).filter(
+      item =>
+        item.result.sensitive &&
+        item.result.level &&
+        levelOrder[item.result.level] >= levelOrder[minLevel]
+    );
+  }
+
+  /**
+   * 
+   */
+  static getLevelDescription(level: SensitivityLevel): string {
+    switch (level) {
+      case SensitivityLevel.LOW:
+        return '低敏感';
+      case SensitivityLevel.MEDIUM:
+        return '中敏感';
+      case SensitivityLevel.HIGH:
+        return '高敏感';
+    }
+  }
+
+  /**
+   * 
+   */
+  static getLevelAction(level: SensitivityLevel): string {
+    switch (level) {
+      case SensitivityLevel.LOW:
+        return '正常流程处理';
+      case SensitivityLevel.MEDIUM:
+        return '需要用户确认';
+      case SensitivityLevel.HIGH:
+        return '默认拒绝访问';
+    }
+  }
+}

package/src/tools/validation/index.ts

@@ -0,0 +1,11 @@
+/**
+ * 
+ */
+
+export { PermissionChecker, DEFAULT_PERMISSION_CONFIG } from './PermissionChecker.js';
+export {
+  SensitiveFileDetector,
+  SensitivityLevel,
+  type SensitivityResult,
+  type SensitivityResultWithPath,
+} from './SensitiveFileDetector.js';

package/src/ui/App.tsx

@@ -0,0 +1,166 @@
+/**
+ * App.tsx - rooted UI with stable references
+ */
+
+import React, { useState, useCallback, useEffect, useRef } from 'react';
+import { Box, Text } from 'ink';
+
+import { ErrorBoundary } from './components/common/ErrorBoundary.js';
+import pkg from '../../package.json' with { type: 'json' };
+import { UpdatePrompt } from './components/dialog/UpdatePrompt.js';
+import { AegisInterface } from './components/AegisInterface.js';
+import { themeManager } from './themes/index.js';
+import type { PermissionMode } from '../cli/types.js';
+import type { VersionCheckResult } from '../services/VersionChecker.js';
+import type { RuntimeConfig, ClawdConfig } from '../config/types.js';
+import { DEFAULT_CONFIG } from '../config/types.js';
+import {
+  ensureStoreInitialized,
+  appActions,
+  configActions,
+  getConfig,
+  useInitializationStatus,
+} from '../store/index.js';
+
+export interface AppProps {
+  apiKey: string;
+  baseURL?: string;
+  model?: string;
+  initialMessage?: string;
+  debug?: boolean;
+  permissionMode?: PermissionMode;
+  versionCheckPromise?: Promise<VersionCheckResult | null>;
+  resumeSessionId?: string;
+  routerEnabled?: boolean;
+}
+
+function mergeRuntimeConfig(baseConfig: ClawdConfig, props: AppProps): RuntimeConfig {
+  const runtimeConfig: RuntimeConfig = { ...baseConfig };
+
+  if (props.initialMessage) runtimeConfig.initialMessage = props.initialMessage;
+  if (props.resumeSessionId) runtimeConfig.resumeSessionId = props.resumeSessionId;
+  if (props.permissionMode) runtimeConfig.defaultPermissionMode = props.permissionMode;
+  if (props.routerEnabled) {
+    runtimeConfig.autoRouter = { ...runtimeConfig.autoRouter, enabled: true };
+  }
+  if (props.model) {
+    // Try to map model name to model ID first
+    const models = baseConfig.models || [];
+    const matched = models.find((m: any) => m.model === props.model || m.id === props.model);
+    runtimeConfig.currentModelId = matched ? matched.id : props.model;
+  }
+
+  return runtimeConfig;
+}
+
+function initializeStoreState(config: RuntimeConfig): void {
+  configActions().setConfig(config);
+
+  const isRealKey = (key?: string) => !!key && !key.startsWith('YOUR_');
+  const hasRealDefault = isRealKey(config.default?.apiKey);
+  const hasRealModel = config.models?.some(m => isRealKey((m as any).apiKey));
+
+  if (!hasRealDefault && !hasRealModel) {
+    appActions().setInitializationStatus('needsSetup');
+  } else {
+    appActions().setInitializationStatus('ready');
+  }
+}
+
+const AppWrapper: React.FC<AppProps> = (props) => {
+  const { versionCheckPromise, permissionMode, ...mainProps } = props;
+  
+  const initializationStatus = useInitializationStatus();
+  
+  const [versionInfo, setVersionInfo] = useState<VersionCheckResult | null>(null);
+  const [showUpdatePrompt, setShowUpdatePrompt] = useState(false);
+  const initDoneRef = useRef(false);
+
+  // Stable initializeApp using ref to avoid re-creating on every render
+  const propsRef = useRef(props);
+  propsRef.current = props;
+  const initializeApp = useCallback(async () => {
+    const p = propsRef.current;
+    if (p.debug) console.log('[DEBUG] Initializing application and Store...');
+    
+    try {
+      appActions().setInitializationStatus('loading');
+      
+      await ensureStoreInitialized();
+      
+      const baseConfig = getConfig() ?? DEFAULT_CONFIG;
+      const mergedConfig = mergeRuntimeConfig(baseConfig, p);
+      initializeStoreState(mergedConfig);
+      
+      initDoneRef.current = true;
+      if (p.debug) console.log('[DEBUG] Store initialized successfully');
+    } catch (error) {
+      appActions().setInitializationError(
+        error instanceof Error ? error.message : 'Unknown initialization error'
+      );
+      if (propsRef.current.debug) console.log('[DEBUG] Store initialization failed:', error);
+    }
+  }, []);
+
+  useEffect(() => {
+    // Start initialization immediately — don't wait for version check
+    const initPromise = initializeApp();
+
+    if (versionCheckPromise) {
+      // Run version check in parallel; only show prompt if init hasn't finished
+      versionCheckPromise
+        .then((versionResult) => {
+          if (versionResult && versionResult.shouldPrompt && !initDoneRef.current) {
+            setVersionInfo(versionResult);
+            setShowUpdatePrompt(true);
+          }
+        })
+        .catch((error) => {
+          if (props.debug) console.log('[DEBUG] Version check failed:', error);
+        });
+    }
+
+    // Keep the lint happy — both are used
+    void initPromise;
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [versionCheckPromise, props.debug]);
+
+  if (showUpdatePrompt && versionInfo) {
+    return (
+      <UpdatePrompt
+        versionInfo={versionInfo}
+        onComplete={async () => {
+          setShowUpdatePrompt(false);
+          await initializeApp();
+        }}
+      />
+    );
+  }
+
+  if (initializationStatus === 'pending' || initializationStatus === 'loading') {
+    return (
+      <Box padding={1}>
+
+      </Box>
+    );
+  }
+
+  if (initializationStatus === 'error') {
+    return (
+      <Box padding={1} flexDirection="column">
+        <Text color="red">❌ Initialization failed</Text>
+        <Text color="gray">Please check your configuration and try again.</Text>
+      </Box>
+    );
+  }
+
+  return <AegisInterface {...mainProps} />;
+};
+
+export const App: React.FC<AppProps> = (props) => {
+  return (
+    <ErrorBoundary>
+      <AppWrapper {...props} />
+    </ErrorBoundary>
+  );
+};