Function bodies 284 total

  async deleteTask(taskId: string): Promise<boolean> {
    // Task ID format: schedule-{slug}
    if (!taskId.startsWith('schedule-')) {
      return false;
    }

    const slug = taskId.slice('schedule-'.length);
    const filePath = path.join(this.schedulesDir, `${slug}.md`);

    try {
      await fs.unlink(filePath);
      logger.info({ taskId, filePath }, 'Deleted schedule file');
      return true;
    } catch (error) {
      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
        return false;
      }
      throw error;
    }
  }

  getFilePath(taskId: string): string {
    const slug = taskId.startsWith('schedule-')
      ? taskId.slice('schedule-'.length)
      : taskId;
    return path.join(this.schedulesDir, `${slug}.md`);
  }

  constructor(options: ScheduleFileWatcherOptions) {
    this.schedulesDir = options.schedulesDir;
    this.onFileAdded = options.onFileAdded;
    this.onFileChanged = options.onFileChanged;
    this.onFileRemoved = options.onFileRemoved;
    this.debounceMs = options.debounceMs ?? 100;
  }

  async start(): Promise<void> {
    if (this.running) {
      logger.warn('File watcher already running');
      return;
    }

    // Ensure directory exists
    await fs.promises.mkdir(this.schedulesDir, { recursive: true });

    try {
      this.watcher = fs.watch(
        this.schedulesDir,
        { persistent: true, recursive: false },
        (eventType, filename) => {
          this.handleFileEvent(eventType, filename);
        }
      );

      this.watcher.on('error', (error) => {
        logger.error({ err: error }, 'File watcher error');
      });

      this.running = true;
      logger.info({ schedulesDir: this.schedulesDir }, 'File watcher started');

    } catch (error) {
      logger.error({ err: error }, 'Failed to start file watcher');
      throw error;
    }
  }

  stop(): void {
    if (this.watcher) {
      this.watcher.close();
      this.watcher = null;
    }

    // Clear all debounce timers
    for (const timer of this.debounceTimers.values()) {
      clearTimeout(timer);
    }
    this.debounceTimers.clear();

    this.running = false;
    logger.info('File watcher stopped');
  }

  private handleFileEvent(eventType: string, filename: string | null): void {
    if (!filename || !filename.endsWith('.md')) {
      return;
    }

    const filePath = path.join(this.schedulesDir, filename);
    logger.debug({ eventType, filename }, 'File event received');

    // Clear existing timer for this file
    const existingTimer = this.debounceTimers.get(filePath);
    if (existingTimer) {
      clearTimeout(existingTimer);
    }

    // Debounce the event
    const timer = setTimeout(() => {
      this.debounceTimers.delete(filePath);
      this.processFileEvent(eventType, filePath, filename);
    }, this.debounceMs);

    this.debounceTimers.set(filePath, timer);
  }

  private async processFileEvent(eventType: string, filePath: string, filename: string): Promise<void> {
    const taskId = this.generateTaskId(filename);

    try {
      if (eventType === 'rename') {
        // Check if file exists to determine if it was added or removed
        const exists = await this.fileExists(filePath);

        if (exists) {
          // File added or renamed to this name
          const task = await this.parseFile(filePath);
          if (task) {
            logger.info({ taskId, filename }, 'Schedule file added');
            this.onFileAdded(task);
          }
        } else {
          // File removed
          logger.info({ taskId, filename }, 'Schedule file removed');
          this.onFileRemoved(taskId, filePath);
        }
      } else if (eventType === 'change') {
        // File modified
        const task = await this.parseFile(filePath);
        if (task) {
          logger.info({ taskId, filename }, 'Schedule file changed');
          this.onFileC

  private async fileExists(filePath: string): Promise<boolean> {
    try {
      await fs.promises.access(filePath);
      return true;
    } catch {
      return false;
    }
  }

  private async parseFile(filePath: string): Promise<ScheduleFileTask | null> {
    try {
      const content = await fs.promises.readFile(filePath, 'utf-8');
      const stats = await fs.promises.stat(filePath);

      const frontmatter = this.parseFrontmatter(content);
      if (!frontmatter['name'] || !frontmatter['cron'] || !frontmatter['chatId']) {
        return null;
      }

      const fileName = path.basename(filePath);
      const prompt = this.extractContent(content);

      return {
        id: this.generateTaskId(fileName),
        name: frontmatter['name'] as string,
        cron: frontmatter['cron'] as string,
        chatId: frontmatter['chatId'] as string,
        prompt,
        enabled: (frontmatter['enabled'] as boolean) ?? true,
        createdBy: frontmatter['createdBy'] as string | undefined,
        createdAt: (frontmatter['createdAt'] as string) || stats.birthtime.toISOString(),
        sourceFile: filePath,
        fileMtime: stats.mtime,
      };
    } catch

  private parseFrontmatter(content: string): Record<string, unknown> {
    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
    const match = content.match(frontmatterRegex);

    if (!match) {
      return {};
    }

    const [, frontmatterText] = match;
    const frontmatter: Record<string, unknown> = {};

    const lines = frontmatterText.split('\n');
    for (const line of lines) {
      const colonIndex = line.indexOf(':');
      if (colonIndex === -1) { continue; }

      const key = line.slice(0, colonIndex).trim();
      const value = line.slice(colonIndex + 1).trim();

      switch (key) {
        case 'name':
        case 'cron':
        case 'chatId':
        case 'createdBy':
        case 'createdAt':
          frontmatter[key] = value.replace(/^["']|["']$/g, '');
          break;
        case 'enabled':
          frontmatter[key] = value === 'true';
          break;
      }
    }

    return frontmatter;
  }

  constructor(options: ScheduleManagerOptions) {
    this.fileScanner = new ScheduleFileScanner({ schedulesDir: options.schedulesDir });
    this.maxTasksPerChat = options.maxTasksPerChat ?? 50;
    this.maxSameNameTasks = options.maxSameNameTasks ?? 1;
    logger.info(
      { schedulesDir: options.schedulesDir, maxTasksPerChat: this.maxTasksPerChat },
      'ScheduleManager initialized (no cache)'
    );
  }

  private async loadAll(): Promise<Map<string, ScheduledTask>> {
    const tasks = await this.fileScanner.scanAll();
    const map = new Map<string, ScheduledTask>();
    for (const task of tasks) {
      map.set(task.id, task);
    }
    return map;
  }

  async create(options: CreateScheduleOptions): Promise<ScheduledTask> {
    // Validate: Check task count limit for this chatId
    const existingTasks = await this.listByChatId(options.chatId);
    if (existingTasks.length >= this.maxTasksPerChat) {
      throw new Error(
        `Task limit exceeded: maximum ${this.maxTasksPerChat} tasks per chat. ` +
        `Please delete some existing tasks first.`
      );
    }

    // Validate: Check for tasks with the same name (prevent infinite recursion)
    const sameNameTasks = existingTasks.filter(t => t.name === options.name);
    if (sameNameTasks.length >= this.maxSameNameTasks) {
      throw new Error(
        `Task "${options.name}" already exists. ` +
        `Please use a different name or delete the existing task first.`
      );
    }

    const slug = this.generateSlug(options.name);
    const task: ScheduledTask = {
      id: `schedule-${slug}`,
      name: options.name,
      cron: options.cron,
      prompt: options.prompt,

  private generateSlug(name: string): string {
    const baseSlug = name
      .toLowerCase()
      .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
      .replace(/^-+|-+$/g, '');

    // Add short UUID to ensure uniqueness
    const shortId = uuidv4().slice(0, 8);
    return `${baseSlug}-${shortId}`;
  }

  async update(id: string, updates: Partial<Omit<ScheduledTask, 'id' | 'createdAt'>>): Promise<ScheduledTask | undefined> {
    const tasks = await this.loadAll();
    const task = tasks.get(id);
    if (!task) {
      return undefined;
    }

    const updatedTask: ScheduledTask = {
      ...task,
      ...updates,
    };

    // Write to file
    await this.fileScanner.writeTask(updatedTask);

    logger.info({ taskId: id, updates }, 'Updated scheduled task');
    return updatedTask;
  }

  constructor(options: SchedulerOptions) {
    this.scheduleManager = options.scheduleManager;
    this.pilot = options.pilot;
    this.callbacks = options.callbacks;
    logger.info('Scheduler created');
  }

  async start(): Promise<void> {
    if (this.running) {
      logger.warn('Scheduler already running');
      return;
    }

    this.running = true;

    // Load and schedule all enabled tasks
    const tasks = await this.scheduleManager.listEnabled();
    for (const task of tasks) {
      await this.addTask(task);
    }

    logger.info({ taskCount: this.activeJobs.size }, 'Scheduler started');
  }

  stop(): void {
    this.running = false;

    for (const [taskId, entry] of this.activeJobs) {
      void entry.job.stop();
      logger.debug({ taskId }, 'Stopped cron job');
    }

    this.activeJobs.clear();
    logger.info('Scheduler stopped');
  }

  addTask(task: ScheduledTask): void {
    // Remove existing job if any
    this.removeTask(task.id);

    if (!task.enabled) {
      logger.debug({ taskId: task.id }, 'Task is disabled, not scheduling');
      return;
    }

    try {
      const job = new CronJob(
        task.cron,
        () => this.executeTask(task),
        null,
        true, // start
        'Asia/Shanghai' // timezone
      );

      this.activeJobs.set(task.id, { taskId: task.id, job, task });
      logger.info({ taskId: task.id, cron: task.cron, name: task.name }, 'Scheduled task');
    } catch (error) {
      logger.error({ err: error, taskId: task.id, cron: task.cron }, 'Invalid cron expression');
    }
  }

  removeTask(taskId: string): void {
    const entry = this.activeJobs.get(taskId);
    if (entry) {
      void entry.job.stop();
      this.activeJobs.delete(taskId);
      logger.info({ taskId }, 'Removed scheduled task');
    }
  }

  private buildScheduledTaskPrompt(task: ScheduledTask): string {
    return `⚠️ **Scheduled Task Execution Context**

You are executing a scheduled task named "${task.name}".

**IMPORTANT RULES:**
1. Do NOT create new scheduled tasks
2. Do NOT modify existing scheduled tasks
3. Focus on completing the task described below
4. If you need to run something periodically, report this need to the user instead

Scheduled task creation is blocked during scheduled task execution to prevent infinite recursion.

---

**Task Prompt:**
${task.prompt}`;
  }

  private async executeTask(task: ScheduledTask): Promise<void> {
    // Check blocking mechanism
    if (task.blocking && this.runningTasks.has(task.id)) {
      logger.info(
        { taskId: task.id, name: task.name },
        'Task skipped - previous execution still running'
      );
      return;
    }

    logger.info({ taskId: task.id, name: task.name }, 'Executing scheduled task');

    // Mark task as running
    this.runningTasks.add(task.id);

    try {
      // Send start notification
      await this.callbacks.sendMessage(
        task.chatId,
        `⏰ 定时任务「${task.name}」开始执行...`
      );

      // Build wrapped prompt with anti-recursion instructions
      const wrappedPrompt = this.buildScheduledTaskPrompt(task);

      // Execute task using Pilot's executeOnce method
      await this.pilot.executeOnce(
        task.chatId,
        wrappedPrompt,
        `${task.id}-${Date.now()}`,
        task.createdBy
      );

      // Update last execution time
      await this.sch

  constructor(config: FileStorageConfig) {
    this.storageDir = config.storageDir;
    this.maxFileSize = config.maxFileSize ?? 100 * 1024 * 1024; // 100MB

    logger.info({
      storageDir: this.storageDir,
      maxFileSize: this.maxFileSize,
    }, 'FileStorageService created');
  }

  async storeFromLocal(
    localPath: string,
    fileName: string,
    mimeType?: string,
    source: 'user' | 'agent' = 'user',
    chatId?: string
  ): Promise<FileReference> {
    const stats = await fs.stat(localPath);

    if (stats.size > this.maxFileSize) {
      throw new Error(`File size exceeds maximum allowed size: ${stats.size} > ${this.maxFileSize}`);
    }

    const fileRef = createFileReference(fileName, source, {
      mimeType,
      size: stats.size,
      chatId,
    });

    const fileDir = path.join(this.storageDir, fileRef.id);
    await fs.mkdir(fileDir, { recursive: true });

    const storedPath = path.join(fileDir, fileName);
    await fs.copyFile(localPath, storedPath);

    fileRef.storageKey = storedPath;
    this.files.set(fileRef.id, { ref: fileRef, localPath: storedPath });

    logger.info({
      fileId: fileRef.id,
      fileName,
      size: stats.size,
      source,
    }, 'File stored from local path');

    return fileRef;
  }

  async storeFromBase64(
    content: string,
    fileName: string,
    mimeType?: string,
    source: 'user' | 'agent' = 'agent',
    chatId?: string
  ): Promise<FileReference> {
    const buffer = Buffer.from(content, 'base64');

    if (buffer.length > this.maxFileSize) {
      throw new Error(`File size exceeds maximum allowed size: ${buffer.length} > ${this.maxFileSize}`);
    }

    const fileRef = createFileReference(fileName, source, {
      mimeType,
      size: buffer.length,
      chatId,
    });

    const fileDir = path.join(this.storageDir, fileRef.id);
    await fs.mkdir(fileDir, { recursive: true });

    const storedPath = path.join(fileDir, fileName);
    await fs.writeFile(storedPath, buffer);

    fileRef.storageKey = storedPath;
    this.files.set(fileRef.id, { ref: fileRef, localPath: storedPath });

    logger.info({
      fileId: fileRef.id,
      fileName,
      size: buffer.length,
      source,
    }, 'File stored from base64');

    return fileRef;
  }

  async getContent(fileId: string): Promise<string> {
    const stored = this.files.get(fileId);
    if (!stored) {
      throw new Error(`File not found: ${fileId}`);
    }

    const buffer = await fs.readFile(stored.localPath);
    return buffer.toString('base64');
  }

function readJsonBody<T>(req: IncomingMessage, maxSize: number): Promise<T> {
  return new Promise((resolve, reject) => {
    let body = '';
    let size = 0;

    req.on('data', (chunk: Buffer) => {
      size += chunk.length;
      if (size > maxSize) {
        req.destroy();
        reject(new Error(`Request body too large: ${size} > ${maxSize}`));
        return;
      }
      body += chunk.toString();
    });

    req.on('end', () => {
      try {
        resolve(JSON.parse(body) as T);
      } catch (error) {
        reject(new Error(`Invalid JSON: ${(error as Error).message}`));
      }
    });

    req.on('error', reject);
  });
}

export function createFileTransferAPIHandler(config: FileTransferAPIConfig) {
  const { storageService, maxBodySize = 100 * 1024 * 1024 } = config;

  /**
   * Handle file API requests.
   */
  return async (req: IncomingMessage, res: ServerResponse): Promise<boolean> => {
    const url = req.url || '/';
    const method = req.method || 'GET';

    // Parse URL path
    const [urlPath] = url.split('?');
    const pathParts = urlPath.split('/').filter(Boolean);

    // Check if this is a file API request
    if (pathParts[0] !== 'api' || pathParts[1] !== 'files') {
      return false; // Not a file API request
    }

    try {
      // GET /api/files - Get storage stats
      if (method === 'GET' && pathParts.length === 2) {
        const stats = storageService.getStats();
        sendJson(res, 200, { success: true, data: stats });
        return true;
      }

      // POST /api/files - Upload file
      if (method === 'POST' && pathParts.length === 2) {
        const request = await r

  buildWarning(reason: string, taskId?: string): string {
    const parts = [
      '⚠️ **任务完成但无反馈消息**',
      '',
      `结束原因: ${reason}`,
    ];

    if (taskId) {
      parts.push(`任务 ID: ${taskId}`);
    }

    parts.push('', '这可能表示:');
    parts.push('- Agent 没有生成任何输出');
    parts.push('- 所有消息都通过内部工具处理');
    parts.push('- 可能存在配置问题');

    return parts.join('\n');
  }

  constructor(config: DialogueOrchestratorConfig) {
    this.evaluatorConfig = config.evaluatorConfig;

    // Initialize extracted services
    this.messageTracker = new DialogueMessageTracker();
    this.fileManager = new TaskFileManager();
  }

  cleanup(): void {
    logger.debug({ taskId: this.taskId }, 'Cleaning up dialogue orchestrator');
    this.taskId = '';
    this.currentChatId = undefined;
    this.messageTracker.reset();
  }

  private async writeFinalSummary(): Promise<void> {
    try {
      const summary = this.generateFinalSummary();
      await this.fileManager.writeFinalSummary(this.taskId, summary);
      logger.info({ taskId: this.taskId }, 'Final summary written');
    } catch (error) {
      logger.error({ err: error, taskId: this.taskId }, 'Failed to write final summary');
    }
  }

  private generateFinalSummary(): string {
    const timestamp = new Date().toISOString();
    const duration = this.iterationCount > 0 ? `${this.iterationCount} iterations` : 'Unknown';

    return `# Final Summary: ${this.taskId}

**Task ID**: ${this.taskId}
**Completed**: ${timestamp}
**Total Iterations**: ${this.iterationCount}
**Total Duration**: ${duration}

## Overview

Task completed successfully after ${this.iterationCount} iteration(s).

## Iteration History

${Array.from({ length: this.iterationCount }, (_, i) => `- Iteration ${i + 1}: Executed`).join('\n')}

## Final Results

✅ Task completed - all objectives achieved

## Key Deliverables

- Task specification: \`tasks/${this.taskId}/task.md\`
- Evaluation results: \`tasks/${this.taskId}/iterations/iter-*/evaluation.md\`
- Execution results: \`tasks/${this.taskId}/iterations/iter-*/execution.md\`
- Final result: \`tasks/${this.taskId}/final_result.md\`

## Lessons Learned

Task execution completed successfully with file-dri

  constructor(workspaceDir?: string, private readonly subdirectory?: string) {
    this.workspaceDir = workspaceDir || Config.getWorkspaceDir();
    this.tasksBaseDir = this.subdirectory
      ? path.join(this.workspaceDir, 'tasks', this.subdirectory)
      : path.join(this.workspaceDir, 'tasks');
  }

  private async ensureBaseDir(): Promise<void> {
    try {
      await fs.mkdir(this.tasksBaseDir, { recursive: true });
    } catch (error) {
      logger.error({ err: error }, 'Failed to create base tasks directory');
      throw error;
    }
  }

  async initializeTask(taskId: string): Promise<void> {
    await this.ensureBaseDir();

    const taskDir = this.getTaskDir(taskId);
    const iterationsDir = this.getIterationsDir(taskId);

    try {
      await fs.mkdir(iterationsDir, { recursive: true });
      logger.debug({ taskId, taskDir }, 'Task directory initialized');
    } catch (error) {
      logger.error({ err: error, taskId }, 'Failed to initialize task directory');
      throw error;
    }
  }

  async writeTaskSpec(taskId: string, content: string): Promise<void> {
    const taskDir = this.getTaskDir(taskId);
    const taskSpecPath = path.join(taskDir, 'task.md');

    try {
      await fs.writeFile(taskSpecPath, content, 'utf-8');
      logger.debug({ taskId, path: taskSpecPath }, 'Task spec written');
    } catch (error) {
      logger.error({ err: error, taskId }, 'Failed to write task spec');
      throw error;
    }
  }

  async readTaskSpec(taskId: string): Promise<string> {
    const taskSpecPath = path.join(this.getTaskDir(taskId), 'task.md');

    try {
      const content = await fs.readFile(taskSpecPath, 'utf-8');
      return content;
    } catch (error) {
      logger.error({ err: error, taskId }, 'Failed to read task spec');
      throw error;
    }
  }

  async createIteration(taskId: string, iteration: number): Promise<void> {
    const iterationDir = this.getIterationDir(taskId, iteration);
    const stepsDir = this.getStepsDir(taskId, iteration);

    try {
      await fs.mkdir(stepsDir, { recursive: true });
      logger.debug({ taskId, iteration, iterationDir }, 'Iteration directory created');
    } catch (error) {
      logger.error({ err: error, taskId, iteration }, 'Failed to create iteration directory');
      throw error;
    }
  }

  async writeEvaluation(taskId: string, iteration: number, content: string): Promise<void> {
    const evaluationPath = path.join(this.getIterationDir(taskId, iteration), 'evaluation.md');

    try {
      await fs.writeFile(evaluationPath, content, 'utf-8');
      logger.debug({ taskId, iteration }, 'Evaluation written');
    } catch (error) {
      logger.error({ err: error, taskId, iteration }, 'Failed to write evaluation');
      throw error;
    }
  }

  async readEvaluation(taskId: string, iteration: number): Promise<string> {
    const evaluationPath = path.join(this.getIterationDir(taskId, iteration), 'evaluation.md');

    try {
      const content = await fs.readFile(evaluationPath, 'utf-8');
      return content;
    } catch (error) {
      logger.error({ err: error, taskId, iteration }, 'Failed to read evaluation');
      throw error;
    }
  }

  async hasEvaluation(taskId: string, iteration: number): Promise<boolean> {
    const evaluationPath = this.getEvaluationPath(taskId, iteration);

    try {
      await fs.access(evaluationPath);
      return true;
    } catch {
      return false;
    }
  }

  async writeExecution(taskId: string, iteration: number, content: string): Promise<void> {
    const executionPath = this.getExecutionPath(taskId, iteration);

    try {
      await fs.writeFile(executionPath, content, 'utf-8');
      logger.debug({ taskId, iteration }, 'Execution written');
    } catch (error) {
      logger.error({ err: error, taskId, iteration }, 'Failed to write execution');
      throw error;
    }
  }

  async readExecution(taskId: string, iteration: number): Promise<string> {
    const executionPath = this.getExecutionPath(taskId, iteration);

    try {
      const content = await fs.readFile(executionPath, 'utf-8');
      return content;
    } catch (error) {
      logger.error({ err: error, taskId, iteration }, 'Failed to read execution');
      throw error;
    }
  }

  async hasExecution(taskId: string, iteration: number): Promise<boolean> {
    const executionPath = this.getExecutionPath(taskId, iteration);

    try {
      await fs.access(executionPath);
      return true;
    } catch {
      return false;
    }
  }

  async writeStepResult(taskId: string, iteration: number, step: number, content: string): Promise<void> {
    const stepResultPath = path.join(this.getStepsDir(taskId, iteration), `step-${step}.md`);

    try {
      await fs.writeFile(stepResultPath, content, 'utf-8');
      logger.debug({ taskId, iteration, step }, 'Step result written');
    } catch (error) {
      logger.error({ err: error, taskId, iteration, step }, 'Failed to write step result');
      throw error;
    }
  }

  async writeFinalSummary(taskId: string, content: string): Promise<void> {
    const summaryPath = path.join(this.getIterationsDir(taskId), 'final-summary.md');

    try {
      await fs.writeFile(summaryPath, content, 'utf-8');
      logger.info({ taskId, summaryPath }, 'Final summary written');
    } catch (error) {
      logger.error({ err: error, taskId }, 'Failed to write final summary');
      throw error;
    }
  }

  async taskExists(taskId: string): Promise<boolean> {
    const taskDir = this.getTaskDir(taskId);

    try {
      await fs.access(taskDir);
      return true;
    } catch {
      return false;
    }
  }

  async listIterations(taskId: string): Promise<number[]> {
    const iterationsDir = this.getIterationsDir(taskId);

    try {
      const entries = await fs.readdir(iterationsDir, { withFileTypes: true });
      const iterations: number[] = [];

      for (const entry of entries) {
        if (entry.isDirectory() && entry.name.startsWith('iter-')) {
          const match = entry.name.match(/^iter-(\d+)$/);
          if (match) {
            iterations.push(parseInt(match[1], 10));
          }
        }
      }

      return iterations.sort((a, b) => a - b);
    } catch (error) {
      logger.error({ err: error, taskId }, 'Failed to list iterations');
      return [];
    }
  }

  async cleanupTask(taskId: string): Promise<void> {
    const taskDir = this.getTaskDir(taskId);

    try {
      await fs.rm(taskDir, { recursive: true, force: true });
      logger.info({ taskId }, 'Task directory cleaned up');
    } catch (error) {
      logger.error({ err: error, taskId }, 'Failed to cleanup task directory');
      throw error;
    }
  }