xshat-lite 1.0.0

package/src/modules/task-runner.mjs

@@ -0,0 +1,511 @@
+import config from '../utils/config.mjs';
+import { runAgentLoop } from './agent-loop.mjs';
+import { buildAgentPrimer } from './chat-helpers.mjs';
+import { requiresBrowserForProvider } from './provider-runtime.mjs';
+import { getAgentSystemPrompt } from './response-parser.mjs';
+import { normalizeResponseEnvelope } from './response-pipeline.mjs';
+import {
+  getAgentRoleLabel,
+  inferAgentRoleFromCommand
+} from './multi-agent.mjs';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function isDue(task) {
+  if (task.status !== 'queued') {
+    return false;
+  }
+
+  if (!task.nextRunAt) {
+    return true;
+  }
+
+  return new Date(task.nextRunAt).getTime() <= Date.now();
+}
+
+function normalizeTaskMode(mode = 'once') {
+  const value = String(mode || 'once').trim().toLowerCase();
+  if (['loop', 'watch', 'interval'].includes(value)) {
+    return value;
+  }
+  return 'once';
+}
+
+function resolveNextRun(task, { success = true } = {}) {
+  const mode = normalizeTaskMode(task.mode);
+  const intervalMs = Math.max(0, Number(task.intervalMs) || 0);
+  const retryDelayMs = Math.max(
+    0,
+    Number(task.retryDelayMs || intervalMs || 5000) || 5000
+  );
+
+  if (!success) {
+    const retryLimit = Math.max(0, Number(task.retryLimit) || 0);
+    const retryCount = Math.max(0, Number(task.retryCount) || 0);
+    if (retryCount < retryLimit) {
+      return new Date(Date.now() + retryDelayMs).toISOString();
+    }
+    if (mode !== 'once' && intervalMs > 0) {
+      return new Date(Date.now() + intervalMs).toISOString();
+    }
+    return null;
+  }
+
+  if (mode === 'once') {
+    return null;
+  }
+
+  if (mode === 'loop' || mode === 'watch') {
+    return nowIso();
+  }
+
+  if (mode === 'interval' && intervalMs > 0) {
+    return new Date(Date.now() + intervalMs).toISOString();
+  }
+
+  return nowIso();
+}
+
+function taskPrompt(task) {
+  return [
+    `你正在执行一个长期任务。任务标题: ${task.title}`,
+    `任务目标: ${task.goal}`,
+    '优先做最小必要动作，并在完成后给出简短总结。',
+    '如果需要继续任务，请输出 action。',
+    '如果任务已经完成，请输出 reply。'
+  ].join('\n');
+}
+
+function isMultiAgentEnabled() {
+  return Boolean(config.agent?.enabled) && Boolean(config.agent?.multiAgent);
+}
+
+function resolveAgentRole(command = null, explicitRole = null) {
+  return explicitRole || inferAgentRoleFromCommand(command) || 'orchestrator';
+}
+
+function formatHistoryDetail(parsed) {
+  const roleLabel = parsed.agentLabel || getAgentRoleLabel(resolveAgentRole(parsed.command, parsed.agent));
+  const main = parsed.displayText || parsed.text || parsed.command?.name || parsed.kind;
+  return roleLabel ? `${roleLabel} · ${main}` : main;
+}
+
+function getTaskErrorMessage(error, fallback = '任务执行失败') {
+  if (!error) {
+    return fallback;
+  }
+
+  const message = String(error?.message || error).trim();
+  return message || fallback;
+}
+
+export class TaskRunner {
+  constructor({
+    taskStore,
+    browserManager,
+    logger,
+    getProvider,
+    createChatManager,
+    createAgentExecutor,
+    sessionCompressionOptions,
+    pollInterval = config.tasks.pollInterval
+  }) {
+    this.taskStore = taskStore;
+    this.browserManager = browserManager;
+    this.logger = logger;
+    this.getProvider = getProvider;
+    this.createChatManager = createChatManager;
+    this.createAgentExecutor = createAgentExecutor;
+    this.sessionCompressionOptions = sessionCompressionOptions;
+    this.pollInterval = pollInterval;
+    this.activeRuns = new Map();
+    this.loopTimer = null;
+    this.running = false;
+  }
+
+  async getRuntimeSnapshot() {
+    const tasks = await this.taskStore.list();
+    const activeIds = new Set(this.activeRuns.keys());
+    return {
+      total: tasks.length,
+      activeTaskIds: [...activeIds],
+      idle: tasks.filter((task) => task.status === 'idle').length,
+      queued: tasks.filter((task) => task.status === 'queued').length,
+      running: tasks.filter((task) => task.status === 'running').length,
+      completed: tasks.filter((task) => task.status === 'completed').length,
+      stopped: tasks.filter((task) => task.status === 'stopped').length,
+      handoff: tasks.filter((task) => task.status === 'handoff').length,
+      failed: tasks.filter((task) => task.status === 'failed').length,
+      tasks
+    };
+  }
+
+  async init() {
+    await this.taskStore.init();
+  }
+
+  startLoop() {
+    if (this.loopTimer) {
+      return;
+    }
+
+    this.loopTimer = setInterval(() => {
+      this.tick().catch(() => {});
+    }, this.pollInterval);
+  }
+
+  stopLoop() {
+    if (this.loopTimer) {
+      clearInterval(this.loopTimer);
+      this.loopTimer = null;
+    }
+  }
+
+  async tick() {
+    const tasks = await this.taskStore.list();
+    const dueTasks = tasks.filter((task) => isDue(task));
+
+    for (const task of dueTasks) {
+      if (this.activeRuns.has(task.id)) {
+        continue;
+      }
+      this.runTask(task.id).catch(() => {});
+    }
+  }
+
+  async createTask({
+    title,
+    goal,
+    provider,
+    mode = 'once',
+    intervalMs = null,
+    retryLimit = 0,
+    retryDelayMs = null
+  }) {
+    const task = this.taskStore.create({
+      title,
+      goal,
+      provider,
+      mode,
+      intervalMs,
+      retryLimit,
+      retryDelayMs
+    });
+    return this.taskStore.save(task);
+  }
+
+  async updateTask(id, updater) {
+    return this.taskStore.update(id, updater);
+  }
+
+  async queueTask(id) {
+    return this.taskStore.update(id, (task) => ({
+      ...task,
+      status: 'queued',
+      stopRequested: false,
+      retryCount: 0,
+      lastError: null,
+      handoffUrl: null,
+      nextRunAt: task.nextRunAt || nowIso()
+    }));
+  }
+
+  async retryTask(id, { run = true } = {}) {
+    const updated = await this.taskStore.update(id, (task) => ({
+      ...task,
+      status: 'queued',
+      stopRequested: false,
+      retryCount: 0,
+      lastError: null,
+      handoffUrl: null,
+      nextRunAt: nowIso()
+    }));
+
+    if (updated && run) {
+      this.runTask(id).catch(() => {});
+    }
+
+    return updated;
+  }
+
+  async stopTask(id) {
+    return this.taskStore.update(id, {
+      stopRequested: true,
+      status: 'stopping'
+    });
+  }
+
+  async runTask(id) {
+    if (this.activeRuns.has(id)) {
+      return this.activeRuns.get(id);
+    }
+
+    const promise = this.#runTaskInternal(id).finally(() => {
+      this.activeRuns.delete(id);
+    });
+    this.activeRuns.set(id, promise);
+    return promise;
+  }
+
+  async #recordFailure(id, task, error, {
+    fallbackMessage = '任务执行失败',
+    appendHistory = true
+  } = {}) {
+    const currentTask = (await this.taskStore.load(id)) || task;
+    if (!currentTask) {
+      return null;
+    }
+
+    const errorMessage = getTaskErrorMessage(error, fallbackMessage);
+    const retryCount = Math.max(0, Number(currentTask.retryCount) || 0) + 1;
+    const nextRunAt = resolveNextRun({
+      ...currentTask,
+      retryCount
+    }, { success: false });
+
+    const updated = await this.taskStore.update(id, {
+      status: nextRunAt ? 'queued' : 'failed',
+      retryCount,
+      nextRunAt,
+      lastError: errorMessage,
+      lastResult: errorMessage
+    });
+
+    if (appendHistory) {
+      await this.taskStore.appendHistory(id, {
+        type: 'error',
+        label: nextRunAt ? '任务失败，等待重试' : '任务失败',
+        detail: errorMessage
+      });
+    }
+
+    return updated;
+  }
+
+  async #runTaskInternal(id) {
+    let task = await this.taskStore.load(id);
+    if (!task) {
+      return null;
+    }
+
+    try {
+      task = await this.taskStore.update(id, {
+        status: 'running',
+        stopRequested: false,
+        lastError: null,
+        lastRunAt: new Date().toISOString(),
+        runCount: (task.runCount || 0) + 1
+      });
+
+      await this.taskStore.appendHistory(id, {
+        type: 'status',
+        label: '任务启动',
+        detail: task.goal
+      });
+
+      const provider = this.getProvider(task.provider);
+      if (!provider) {
+        throw new Error(`未找到提供方: ${task.provider || '(空)'}`);
+      }
+
+      if (requiresBrowserForProvider(provider)) {
+        if (!this.browserManager.isReady()) {
+          await this.browserManager.init();
+        }
+
+        await this.browserManager.goto(provider.url);
+        await sleep(1200);
+      }
+
+      const chatManager = this.createChatManager(provider);
+      const agentExecutor = this.createAgentExecutor();
+
+      const primer = buildAgentPrimer(
+        getAgentSystemPrompt({
+          providerId: provider?.id || '',
+          multiAgentEnabled: isMultiAgentEnabled(),
+          allowShell: Boolean(config.agent?.allowShell),
+          allowFileWrite: Boolean(config.agent?.allowFileWrite)
+        }),
+        [
+          { role: 'user', content: taskPrompt(task) }
+        ],
+        this.sessionCompressionOptions()
+      );
+
+      const primerSent = await chatManager.sendMessage(primer);
+      if (primerSent) {
+        try {
+          await sleep(800);
+          await chatManager.waitForResponse(() => {});
+        } catch {
+          // ignore primer ack timeout
+        }
+      }
+
+      const sent = await chatManager.sendMessage(taskPrompt(task));
+      if (!sent) {
+        await this.#recordFailure(id, task, '任务消息发送失败');
+        return null;
+      }
+
+      await this.taskStore.appendMessage(id, 'user', task.goal);
+
+      let step = 0;
+      const maxSteps = Math.max(2, Number(config.agent?.maxAutoSteps) || 4);
+      let lastResult = null;
+
+      while (step < maxSteps) {
+        const latestTask = await this.taskStore.load(id);
+        if (!latestTask || latestTask.stopRequested) {
+          await this.taskStore.update(id, {
+            status: 'stopped',
+            nextRunAt: null,
+            lastResult: lastResult?.message || '任务已停止'
+          });
+          await this.taskStore.appendHistory(id, {
+            type: 'status',
+            label: '任务停止',
+            detail: '收到停止请求'
+          });
+          return null;
+        }
+
+        const response = await chatManager.waitForResponse(() => {});
+        await this.taskStore.appendMessage(id, 'assistant', response);
+
+        const parsed = normalizeResponseEnvelope(response, { agentMode: true });
+
+        await this.taskStore.appendHistory(id, {
+          type: 'model',
+          label: `第 ${step + 1} 步`,
+          detail: formatHistoryDetail(parsed),
+          agentRole: resolveAgentRole(parsed.command, parsed.agent),
+          agentLabel: parsed.agentLabel || getAgentRoleLabel(resolveAgentRole(parsed.command, parsed.agent))
+        });
+
+        const outcome = await runAgentLoop({
+          initialEnvelope: parsed,
+          initialStep: step,
+          maxSteps,
+          agentExecutor,
+          requestFollowupResponse: async (followupMessage) => {
+            const followupSent = await chatManager.sendMessage(followupMessage);
+            if (!followupSent) {
+              throw new Error('后续消息发送失败');
+            }
+
+            return chatManager.waitForResponse(() => {});
+          },
+          onAfterCommand: async ({ envelope, result }) => {
+            lastResult = result;
+            await this.taskStore.appendHistory(id, {
+              type: 'action',
+              label: envelope.command.name,
+              detail: result.ok
+                ? result.message || '执行完成'
+                : result.error || '执行失败',
+              agentRole: result.agent,
+              agentLabel: getAgentRoleLabel(result.agent)
+            });
+          },
+          onFollowupResponse: async ({ rawResponse, envelope, step }) => {
+            await this.taskStore.appendMessage(id, 'assistant', rawResponse);
+            await this.taskStore.appendHistory(id, {
+              type: 'model',
+              label: `第 ${step + 1} 步`,
+              detail: formatHistoryDetail(envelope),
+              agentRole: resolveAgentRole(envelope.command, envelope.agent),
+              agentLabel:
+                envelope.agentLabel ||
+                getAgentRoleLabel(resolveAgentRole(envelope.command, envelope.agent))
+            });
+          }
+        });
+
+        step = outcome.step;
+
+        if (outcome.status === 'error') {
+          await this.#recordFailure(id, await this.taskStore.load(id), outcome.result?.error || '命令执行失败');
+          return outcome.result;
+        }
+
+        if (outcome.status === 'handoff') {
+          await this.taskStore.update(id, {
+            status: 'handoff',
+            nextRunAt: null,
+            handoffUrl: this.browserManager.getCurrentUrl(),
+            lastResult:
+              outcome.result?.message ||
+              outcome.envelope?.text ||
+              '需要人工接管'
+          });
+          await this.taskStore.appendHistory(id, {
+            type: 'status',
+            label: '等待接管',
+            detail: outcome.result?.message || outcome.envelope?.text || '需要人工接管'
+          });
+          return outcome.result || outcome.envelope;
+        }
+
+        if (outcome.status === 'completed' || outcome.status === 'message') {
+          const currentTask = await this.taskStore.load(id);
+          const nextRunAt = resolveNextRun(currentTask, { success: true });
+          await this.taskStore.update(id, {
+            status: nextRunAt ? 'queued' : 'completed',
+            retryCount: 0,
+            nextRunAt,
+            lastCompletedAt: nowIso(),
+            lastResult:
+              outcome.result?.message ||
+              outcome.envelope?.text ||
+              '任务已完成'
+          });
+          await this.taskStore.appendHistory(id, {
+            type: 'status',
+            label: nextRunAt ? '本轮完成，等待下一次运行' : '任务完成',
+            detail:
+              outcome.result?.message ||
+              outcome.envelope?.text ||
+              '任务已完成'
+          });
+          return outcome.result || outcome.envelope;
+        }
+
+        if (outcome.status === 'limit') {
+          lastResult = outcome.result || lastResult;
+        }
+      }
+
+      const currentTask = await this.taskStore.load(id);
+      const nextRunAt = resolveNextRun(currentTask, { success: true });
+      await this.taskStore.update(id, {
+        status: nextRunAt ? 'queued' : 'completed',
+        retryCount: 0,
+        nextRunAt,
+        lastCompletedAt: nowIso(),
+        lastResult: lastResult?.message || '达到最大自动步数后结束'
+      });
+      await this.taskStore.appendHistory(id, {
+        type: 'status',
+        label: nextRunAt ? '本轮结束，等待下一次运行' : '任务完成',
+        detail: lastResult?.message || '达到最大自动步数后结束'
+      });
+      return lastResult;
+    } catch (error) {
+      await this.#recordFailure(id, task, error);
+      return {
+        ok: false,
+        error: getTaskErrorMessage(error)
+      };
+    }
+  }
+}
+
+export default TaskRunner;