aegiscode 3.1.8 → 3.1.10

package/src/store/types.ts

@@ -0,0 +1,274 @@
+/**
+ * Zustand Store 类型定义
+ */
+
+import type { RuntimeConfig } from '../config/types.js';
+
+// ========== Content Block Model (mirrors Claude SSE content blocks)
+
+export type ContentBlockType = 'text' | 'thinking' | 'tool_use' | 'tool_result';
+
+export type ToolCallStatus = 'running' | 'success' | 'error';
+
+export interface TextBlock {
+  type: 'text';
+  text: string;
+}
+
+export interface ThinkingBlock {
+  type: 'thinking';
+  thinking: string;
+}
+
+export interface ToolUseBlock {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: string;        // JSON args being accumulated
+  status: ToolCallStatus;
+  startedAt: number;
+  completedAt?: number;
+}
+
+export interface ToolResultBlock {
+  type: 'tool_result';
+  tool_use_id: string;
+  content: string;
+  is_error: boolean;
+}
+
+export type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock;
+
+// ========== 会话状
+
+export interface ModelTokens {
+  inputTokens: number;
+  outputTokens: number;
+}
+
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  maxContextTokens: number;
+  modelBreakdown: Record<string, ModelTokens>;
+}
+
+export interface SessionMessage {
+  id: string;
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  timestamp: number;
+  toolCalls?: unknown[];
+  toolCallId?: string;
+  /** 思考过程内容（用于支持 DeepSeek R1 等推理模型） */
+  thinking?: string;
+  isStreaming?: boolean;
+  /** Content blocks for structured rendering (Claude-style: text, thinking, tool_use, tool_result) */
+  contentBlocks?: ContentBlock[];
+}
+
+export interface SessionState {
+  sessionId: string;
+  messages: SessionMessage[];
+  isThinking: boolean;
+  isCompacting: boolean;
+  currentCommand: string | null;
+  error: string | null;
+  isActive: boolean;
+  tokenUsage: TokenUsage;
+}
+
+export interface SessionActions {
+  addMessage: (message: SessionMessage) => void;
+  addUserMessage: (content: string) => void;
+  addAssistantMessage: (content: string) => void;
+  /** 开始流式助手消息（创建空消息占位） */
+  startStreamingMessage: () => string;
+  appendToStreamingMessage: (id: string, contentDelta: string) => void;
+  appendThinkingToStreamingMessage: (id: string, thinkingDelta: string) => void;
+  /** Force-flush streaming buffer content to store (for tool calls, final flush) */
+  flushStreamBuffer: (id: string) => void;
+  /** Write directly to store message, bypassing buffer (for tool calls) */
+  forceAppendToMessage: (id: string, contentDelta: string) => void;
+  finishStreamingMessage: (id: string) => void;
+
+  // ===== Content Block Operations (Claude-style) =====
+  /** Add a content block to the currently streaming message */
+  addContentBlock: (messageId: string, block: ContentBlock) => void;
+  /** Update a tool_use block's accumulated input JSON */
+  updateToolCallInput: (messageId: string, toolCallId: string, partialJson: string) => void;
+  /** Set a tool_use block's full input JSON (replaces, used once on completion) */
+  setToolCallInput: (messageId: string, toolCallId: string, fullInput: string) => void;
+  /** Update a tool_use block's status */
+  updateToolCallStatus: (messageId: string, toolCallId: string, status: ToolCallStatus, completedAt?: number) => void;
+  /** Add a tool_result block linked to a tool_use */
+  addToolResultBlock: (messageId: string, toolUseId: string, content: string, isError: boolean) => void;
+
+  setThinking: (isThinking: boolean) => void;
+  setCompacting: (isCompacting: boolean) => void;
+  setCurrentCommand: (command: string | null) => void;
+  setError: (error: string | null) => void;
+  setSessionId: (sessionId: string) => void;
+  restoreSession: (sessionId: string, messages: SessionMessage[]) => void;
+  updateTokenUsage: (usage: Partial<TokenUsage>) => void;
+  removeLastMessages: (count: number) => void;
+  clearMessages: () => void;
+  resetSession: () => void;
+}
+
+export interface SessionSlice extends SessionState {
+  actions: SessionActions;
+}
+
+// ========== 配置状
+
+export interface ConfigState {
+  config: RuntimeConfig | null;
+}
+
+export interface ConfigActions {
+  setConfig: (config: RuntimeConfig) => void;
+  updateConfig: (partial: Partial<RuntimeConfig>) => void;
+}
+
+export interface ConfigSlice extends ConfigState {
+  actions: ConfigActions;
+}
+
+// ========== 应用状
+
+export type InitializationStatus = 'pending' | 'loading' | 'ready' | 'error' | 'needsSetup';
+export type ActiveModal = 'none' | 'shortcuts' | 'settings' | 'confirmation' | 'update' | 'themeSelector';
+
+export interface AppState {
+  initializationStatus: InitializationStatus;
+  initializationError: string | null;
+  activeModal: ActiveModal;
+  awaitingSecondCtrlC: boolean;
+  /** 是否展开所有思考块（全局开关） */
+  showAllThinking: boolean;
+  todos: TodoItem[];
+  /** Set once the user runs /model this session — auto-router backs off until /router on resets it */
+  manualModelOverride: boolean;
+  /** Display label of the model the auto-router picked for the in-flight/last turn, or null if none */
+  autoRouterActiveModel: string | null;
+  workflow: WorkflowState;
+}
+
+export interface AppActions {
+  setInitializationStatus: (status: InitializationStatus) => void;
+  setInitializationError: (error: string | null) => void;
+  setActiveModal: (modal: ActiveModal) => void;
+  setTodos: (todos: TodoItem[]) => void;
+  addTodo: (todo: TodoItem) => void;
+  updateTodo: (id: string, updates: Partial<TodoItem>) => void;
+  removeTodo: (id: string) => void;
+  setAwaitingSecondCtrlC: (awaiting: boolean) => void;
+  toggleShowAllThinking: () => void;
+  setManualModelOverride: (value: boolean) => void;
+  setAutoRouterActiveModel: (label: string | null) => void;
+  workflow: WorkflowActions;
+}
+
+export interface AppSlice extends AppState {
+  actions: AppActions;
+}
+
+// ========== 焦点状
+
+export type FocusId = 'input' | 'messages' | 'confirmation' | 'modal' | 'none' | 'theme-selector' | 'selector';
+
+/** FocusId 常量枚举 */
+export const FocusId = {
+  MAIN_INPUT: 'input' as FocusId,
+  MESSAGES: 'messages' as FocusId,
+  CONFIRMATION_PROMPT: 'confirmation' as FocusId,
+  THEME_SELECTOR: 'theme-selector' as FocusId,
+  SELECTOR: 'selector' as FocusId,
+  MODAL: 'modal' as FocusId,
+  NONE: 'none' as FocusId,
+} as const;
+
+export interface FocusState {
+  currentFocus: FocusId;
+  previousFocus: FocusId | null;
+}
+
+export interface FocusActions {
+  setFocus: (focus: FocusId) => void;
+  restoreFocus: () => void;
+  pushFocus: (focus: FocusId) => void;
+}
+
+export interface FocusSlice extends FocusState {
+  actions: FocusActions;
+}
+
+// ========== 命令状
+
+export interface CommandState {
+  isProcessing: boolean;
+  abortController: AbortController | null;
+  pendingCommands: string[];
+}
+
+export interface CommandActions {
+  setProcessing: (isProcessing: boolean) => void;
+  createAbortController: () => AbortController;
+  abort: () => void;
+  enqueueCommand: (command: string) => void;
+  dequeueCommand: () => string | undefined;
+  clearQueue: () => void;
+}
+
+export interface CommandSlice extends CommandState {
+  actions: CommandActions;
+}
+
+// ========== Workflow State (for context bar)
+
+export interface WorkflowStep {
+  label: string;
+  status: 'pending' | 'active' | 'done';
+}
+
+export interface WorkflowState {
+  visible: boolean;
+  phase: string;         // "Building", "Refactoring", "Debugging" etc.
+  target: string;        // what's being worked on, e.g. "auth system"
+  steps: WorkflowStep[];
+  currentStepIndex: number;
+  totalSteps: number;
+}
+
+export const initialWorkflowState: WorkflowState = {
+  visible: false,
+  phase: '',
+  target: '',
+  steps: [],
+  currentStepIndex: 0,
+  totalSteps: 0,
+};
+
+export interface WorkflowActions {
+  setWorkflow: (opts: { phase: string; target: string; steps: string[] }) => void;
+  advanceStep: () => void;
+  clearWorkflow: () => void;
+}
+
+// ========== Todo support (for progress tracking in tasks)
+export interface TodoItem {
+  id: string;
+  title: string;
+  status: 'pending' | 'in_progress' | 'completed';
+  createdAt: number;
+}
+
+export interface ClawdStore {
+  session: SessionSlice;
+  config: ConfigSlice;
+  app: AppSlice;
+  focus: FocusSlice;
+  command: CommandSlice;
+}

package/src/store/vanilla.ts

@@ -0,0 +1,186 @@
+/**
+ * Zustand Vanilla Store
+ * 
+ * 
+ */
+
+import { createStore } from 'zustand/vanilla';
+import { devtools, subscribeWithSelector } from 'zustand/middleware';
+
+import type { ClawdStore } from './types.js';
+import type { RuntimeConfig } from '../config/types.js';
+import {
+  createSessionSlice,
+  createConfigSlice,
+  createAppSlice,
+  createFocusSlice,
+  createCommandSlice,
+} from './slices/index.js';
+
+/**
+ * 
+ *
+ * 
+ * - devtools: 开发工具支持
+ * - subscribeWithSelector: 支持选择器订阅
+ */
+export const vanillaStore = createStore<ClawdStore>()(
+  devtools(
+    subscribeWithSelector((...a) => ({
+      session: createSessionSlice(...a),
+      config: createConfigSlice(...a),
+      app: createAppSlice(...a),
+      focus: createFocusSlice(...a),
+      command: createCommandSlice(...a),
+    })),
+    {
+      name: 'ClawdStore',
+      enabled: process.env.NODE_ENV === 'development',
+    }
+  )
+);
+
+// ========== 便捷访问
+
+/**
+ * 
+ */
+export const getState = () => vanillaStore.getState();
+
+/**
+ * 
+ */
+export const subscribe = vanillaStore.subscribe;
+
+// ========== Actions 快捷访
+
+export const sessionActions = () => getState().session.actions;
+export const configActions = () => getState().config.actions;
+export const appActions = () => getState().app.actions;
+export const focusActions = () => getState().focus.actions;
+export const commandActions = () => getState().command.actions;
+
+// ========== 配置便捷访
+
+/**
+ * 
+ */
+export const getConfig = (): RuntimeConfig | null => getState().config.config;
+
+/**
+ * 
+ */
+export const getCurrentModel = () => {
+  const config = getConfig();
+  if (!config) return undefined;
+
+  // 优先使用 currentModelId
+  if (config.currentModelId && config.models) {
+    const model = config.models.find((m) => m.id === config.currentModelId);
+    if (model) return model;
+  }
+
+  // 回退：按 model 字段匹配（兼容 currentModelId 被设为 model name 的情况）
+  if (config.currentModelId && config.models) {
+    const model = config.models.find((m) => m.model === config.currentModelId);
+    if (model) return model;
+  }
+
+  // 回退
+  if (config.models && config.models.length > 0) {
+    return config.models[0];
+  }
+
+  // 回退到 default
+  return config.default;
+};
+
+/**
+ * 
+ */
+export const getPermissionMode = () => {
+  const config = getConfig();
+  return config?.defaultPermissionMode || 'default';
+};
+
+// ========== 初始化机
+
+let initializationPromise: Promise<void> | null = null;
+
+/**
+ * 
+ *
+ * 
+ * - 幂等：已初始化直接返回
+ * - 并发安全：共享 Promise
+ * - 失败重试：下次调用重新尝试
+ */
+export async function ensureStoreInitialized(): Promise<void> {
+  // 1. 快速路径：已初始
+  const config = getConfig();
+  if (config !== null) {
+    return;
+  }
+
+  // 2. 并发保护：等待共
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+
+  // 3. 开始初始
+  initializationPromise = (async () => {
+    try {
+      // 动态导入避免循环依
+      const { ConfigManager } = await import('../config/ConfigManager.js');
+      const configManager = ConfigManager.getInstance();
+      const loadedConfig = await configManager.initialize();
+      getState().config.actions.setConfig(loadedConfig as RuntimeConfig);
+    } catch (error) {
+      initializationPromise = null; // 允许重
+      throw new Error(
+        `❌ Store 初始化失败\n\n` +
+          `原因: ${error instanceof Error ? error.message : '未知错误'}`
+      );
+    } finally {
+      initializationPromise = null;
+    }
+  })();
+
+  return initializationPromise;
+}
+
+// ========== 订阅工
+
+/**
+ * 
+ */
+export function subscribeToState<T>(
+  selector: (state: ClawdStore) => T,
+  callback: (value: T, prevValue: T) => void
+): () => void {
+  return vanillaStore.subscribe((state, prevState) => {
+    const value = selector(state);
+    const prevValue = selector(prevState);
+    if (value !== prevValue) {
+      callback(value, prevValue);
+    }
+  });
+}
+
+/**
+ * 
+ */
+export function subscribeToTodos(
+  callback: (todos: ClawdStore['app']['todos']) => void
+): () => void {
+  return subscribeToState((state) => state.app.todos, callback);
+}
+
+/**
+ * 
+ */
+export function subscribeToMessages(
+  callback: (messages: ClawdStore['session']['messages']) => void
+): () => void {
+  return subscribeToState((state) => state.session.messages, callback);
+}

package/src/tools/builtin/bash.ts

@@ -0,0 +1,236 @@
+/**
+ * Bash 工具
+ * 
+ * 
+ */
+
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { createWriteStream, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { z } from 'zod';
+import { createTool } from '../createTool.js';
+import { ToolKind, ToolErrorType } from '../types.js';
+
+const BG_JOBS_DIR = path.join(os.homedir(), '.aegiscode', 'bg');
+
+const execAsync = promisify(exec);
+
+// ========== Schema 定
+
+const BashSchema = z.object({
+  command: z.string()
+    .min(1, '命令不能为空')
+    .describe('The shell command to execute'),
+  description: z.string()
+    .optional()
+    .describe('A brief description of what the command does (for logging)'),
+  timeout: z.number()
+    .max(600000)
+    .default(120000)
+    .describe('Timeout in milliseconds (max 10 minutes, default 2 minutes)'),
+  working_directory: z.string()
+    .optional()
+    .describe('The working directory to execute the command in'),
+  run_in_background: z.boolean()
+    .default(false)
+    .describe('Whether to run the command in the background'),
+});
+
+// ========== Bash 工
+
+export const bashTool = createTool({
+  name: 'Bash',
+  displayName: 'Shell Command',
+  kind: ToolKind.Execute,
+  schema: BashSchema,
+  
+  // Bash 不是并发安全的（可能修改共享状
+  isConcurrencySafe: false,
+  
+  description: {
+    short: 'Executes bash commands in a shell session',
+    long: 'Executes shell commands and returns the output. Use this for system operations, git commands, package management, etc.',
+    usageNotes: [
+      'Avoid using for file operations - use dedicated tools (Read, Write, Edit) instead',
+      'Do not use cat/head/tail to read files - use the Read tool',
+      'Do not use sed/awk to edit files - use the Edit tool',
+      'Use && to chain dependent commands',
+      'Use run_in_background for long-running dev servers',
+      'Always quote file paths that contain spaces',
+    ],
+    examples: [
+      {
+        description: 'Run npm install',
+        params: {
+          command: 'npm install',
+          description: 'Install npm dependencies',
+        },
+      },
+      {
+        description: 'Check git status',
+        params: {
+          command: 'git status',
+        },
+      },
+      {
+        description: 'Run a build command with timeout',
+        params: {
+          command: 'npm run build',
+          timeout: 300000,
+          description: 'Build the project',
+        },
+      },
+    ],
+    important: [
+      'NEVER use git commands with -i flag (interactive mode)',
+      'NEVER run destructive commands like rm -rf / without explicit user request',
+      'NEVER use echo or printf to communicate - output text directly instead',
+      'Avoid long-running processes that block (like npm run dev) unless using run_in_background',
+    ],
+  },
+
+  category: 'Shell',
+  tags: ['shell', 'bash', 'command', 'execute'],
+
+  // 提取签名内容（用于权限规
+  extractSignatureContent: (params: unknown) => {
+    const p = params as { command: string };
+    return p.command;
+  },
+
+  async execute(params, context) {
+    const { command, description, timeout, working_directory, run_in_background } = params;
+
+    // 危险命令检
+    const dangerousPatterns = [
+      /rm\s+-rf\s+\/(?!\w)/,  // rm -rf / (但允许 rm -rf /path/to/dir)
+      />\s*\/dev\/sd[a-z]/,   // 写入磁盘设
+      /mkfs\./,               // 格式化文件系
+      /dd\s+if=.*of=\/dev/,   // dd 写入设
+    ];
+
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(command)) {
+        return {
+          success: false,
+          llmContent: `Error: Potentially dangerous command detected: ${command}`,
+          displayContent: `blocked: dangerous command`,
+          error: {
+            type: ToolErrorType.PERMISSION_ERROR,
+            message: 'Dangerous command blocked',
+          },
+        };
+      }
+    }
+
+    try {
+      if (run_in_background) {
+        const jobId = `bg-${Date.now()}`;
+        const logPath = path.join(BG_JOBS_DIR, `${jobId}.log`);
+        mkdirSync(BG_JOBS_DIR, { recursive: true });
+
+        const logStream = createWriteStream(logPath, { flags: 'a' });
+        logStream.write(`[${new Date().toISOString()}] $ ${command}\n\n`);
+
+        const child = spawn(command, [], {
+          shell: '/bin/bash',
+          cwd: working_directory || context?.cwd || process.cwd(),
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+
+        child.stdout!.on('data', (chunk: Buffer) => logStream.write(chunk));
+        child.stderr!.on('data', (chunk: Buffer) => logStream.write(chunk));
+        child.on('close', (code: number | null) => {
+          logStream.write(`\n[${new Date().toISOString()}] exited with code ${code}\n`);
+          logStream.end();
+        });
+
+        return {
+          success: true,
+          llmContent: `Background process started.\nJob ID: ${jobId}\nPID: ${child.pid}\nLog file: ${logPath}\n\nMonitor with: tail -f ${logPath}\nCheck output: cat ${logPath}`,
+          displayContent: `▶ bg: ${description || command.substring(0, 50)} (PID ${child.pid})`,
+          metadata: { jobId, pid: child.pid, logPath, command },
+        };
+      }
+
+      // 执行命
+      const options = {
+        timeout,
+        cwd: working_directory || context?.cwd || process.cwd(),
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+        shell: '/bin/bash',
+      };
+
+      const { stdout, stderr } = await execAsync(command, options);
+
+      // 组合输
+      const output = [
+        stdout ? stdout.trim() : '',
+        stderr ? `[stderr]\n${stderr.trim()}` : '',
+      ].filter(Boolean).join('\n\n');
+
+      return {
+        success: true,
+        llmContent: output || '(no output)',
+        displayContent: description
+          ? description
+          : command.length > 60 ? command.substring(0, 60) + '…' : command,
+        metadata: {
+          command,
+          exit_code: 0,
+          working_directory: options.cwd,
+        },
+      };
+    } catch (error: unknown) {
+      // 处理执行错
+      const execError = error as {
+        code?: number | string;
+        killed?: boolean;
+        signal?: string;
+        stdout?: string;
+        stderr?: string;
+        message?: string;
+      };
+
+      // 超时处
+      if (execError.killed && execError.signal === 'SIGTERM') {
+        return {
+          success: false,
+          llmContent: `Command timed out after ${timeout}ms: ${command}`,
+          displayContent: `error: timeout (${timeout}ms)`,
+          error: {
+            type: ToolErrorType.TIMEOUT_ERROR,
+            message: 'Command timed out',
+          },
+        };
+      }
+
+      // 命令执行失
+      const exitCode = typeof execError.code === 'number' ? execError.code : 1;
+      const stderr = execError.stderr || execError.message || 'unknown error';
+      const stdout = execError.stdout || '';
+
+      const output = [
+        stdout ? stdout.trim() : '',
+        stderr ? stderr.trim() : '',
+      ].filter(Boolean).join('\n\n');
+
+      return {
+        success: false,
+        llmContent: `Command failed with exit code ${exitCode}:\n${output}`,
+        displayContent: `error: exit ${exitCode}`,
+        error: {
+          type: ToolErrorType.EXECUTION_ERROR,
+          message: stderr,
+          details: { exit_code: exitCode },
+        },
+        metadata: {
+          command,
+          exit_code: exitCode,
+        },
+      };
+    }
+  },
+});