xshat-lite 1.0.0

package/src/modules/task-store.mjs

@@ -0,0 +1,262 @@
+import fs from 'node:fs/promises';
+import { resolve } from 'node:path';
+import config from '../utils/config.mjs';
+import {
+  readJsonSafe,
+  resolveSiblingPath,
+  writeJsonAtomic
+} from '../utils/storage.mjs';
+
+function nowIso(clock = () => new Date()) {
+  return clock().toISOString();
+}
+
+function summarizeText(text, maxChars = 120) {
+  const value = String(text ?? '').replace(/\s+/g, ' ').trim();
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+
+export class TaskStore {
+  constructor({
+    dir = config.tasks.dir,
+    maxHistory = config.tasks.maxHistory,
+    maxMessages = config.tasks.maxMessages,
+    fsModule = fs,
+    clock = () => new Date()
+  } = {}) {
+    this.dir = dir;
+    this.maxHistory = maxHistory;
+    this.maxMessages = maxMessages;
+    this.fs = fsModule;
+    this.clock = clock;
+    this.indexPath = resolveSiblingPath(this.dir, '_index.json');
+  }
+
+  async init() {
+    await this.fs.mkdir(this.dir, { recursive: true });
+  }
+
+  taskPath(id) {
+    return resolve(this.dir, `${id}.json`);
+  }
+
+  toMeta(task) {
+    if (!task) {
+      return null;
+    }
+
+    return {
+      id: task.id,
+      title: task.title,
+      goal: summarizeText(task.goal, 80),
+      provider: task.provider,
+      mode: task.mode,
+      intervalMs: task.intervalMs ?? null,
+      status: task.status,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      lastRunAt: task.lastRunAt,
+      lastCompletedAt: task.lastCompletedAt || null,
+      nextRunAt: task.nextRunAt,
+      runCount: task.runCount || 0,
+      retryCount: task.retryCount || 0,
+      retryLimit: task.retryLimit || 0,
+      stopRequested: Boolean(task.stopRequested),
+      handoffUrl: task.handoffUrl || null,
+      lastError: task.lastError
+        ? summarizeText(task.lastError, 100)
+        : null,
+      lastResult: task.lastResult
+        ? summarizeText(task.lastResult, 100)
+        : null
+    };
+  }
+
+  async loadIndex() {
+    const index = await readJsonSafe(this.indexPath, []);
+    return Array.isArray(index) ? index : [];
+  }
+
+  async saveIndex(entries = []) {
+    const normalized = entries
+      .filter(Boolean)
+      .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+    await writeJsonAtomic(this.indexPath, normalized);
+  }
+
+  async upsertIndexEntry(task) {
+    const meta = this.toMeta(task);
+    if (!meta?.id) {
+      return;
+    }
+
+    const current = await this.loadIndex();
+    const filtered = current.filter((item) => item?.id !== meta.id);
+    filtered.push(meta);
+    await this.saveIndex(filtered);
+  }
+
+  async removeIndexEntry(id) {
+    const current = await this.loadIndex();
+    await this.saveIndex(current.filter((item) => item?.id !== id));
+  }
+
+  create({
+    title,
+    goal,
+    schedule = null,
+    provider = null,
+    mode = 'once',
+    intervalMs = null,
+    retryLimit = 0,
+    retryDelayMs = null
+  }) {
+    const timestamp = Date.now();
+    const createdAt = nowIso(this.clock);
+    return {
+      id: `task_${timestamp}`,
+      title: String(title || goal || '未命名任务').trim().slice(0, 80),
+      goal: String(goal || '').trim(),
+      provider,
+      mode,
+      schedule,
+      intervalMs:
+        intervalMs === null || intervalMs === undefined
+          ? null
+          : Math.max(0, Number(intervalMs) || 0),
+      retryLimit: Math.max(0, Number(retryLimit) || 0),
+      retryDelayMs:
+        retryDelayMs === null || retryDelayMs === undefined
+          ? null
+          : Math.max(0, Number(retryDelayMs) || 0),
+      status: 'idle',
+      createdAt,
+      updatedAt: createdAt,
+      lastRunAt: null,
+      lastCompletedAt: null,
+      nextRunAt: null,
+      lastError: null,
+      lastResult: null,
+      handoffUrl: null,
+      stopRequested: false,
+      runCount: 0,
+      retryCount: 0,
+      history: [],
+      messages: []
+    };
+  }
+
+  async save(task) {
+    const nextTask = {
+      ...task,
+      updatedAt: nowIso(this.clock),
+      history: Array.isArray(task.history)
+        ? task.history.slice(-this.maxHistory)
+        : [],
+      messages: Array.isArray(task.messages)
+        ? task.messages.slice(-this.maxMessages)
+        : []
+    };
+
+    await writeJsonAtomic(this.taskPath(nextTask.id), nextTask);
+    await this.upsertIndexEntry(nextTask);
+    return nextTask;
+  }
+
+  async load(id) {
+    try {
+      const raw = await this.fs.readFile(this.taskPath(id), 'utf-8');
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  async list() {
+    try {
+      const indexed = await this.loadIndex();
+      if (indexed.length > 0) {
+        return indexed;
+      }
+
+      const files = await this.fs.readdir(this.dir);
+      const tasks = await Promise.all(
+        files
+          .filter((file) => file.endsWith('.json') && file !== '_index.json')
+          .map(async (file) => {
+            try {
+              const raw = await this.fs.readFile(resolve(this.dir, file), 'utf-8');
+              const task = JSON.parse(raw);
+              return this.toMeta(task);
+            } catch {
+              return null;
+            }
+          })
+      );
+
+      const normalized = tasks
+        .filter(Boolean)
+        .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+      await this.saveIndex(normalized);
+      return normalized;
+    } catch {
+      return [];
+    }
+  }
+
+  async update(id, updater) {
+    const task = await this.load(id);
+    if (!task) {
+      return null;
+    }
+
+    const nextTask =
+      typeof updater === 'function'
+        ? updater(task) || task
+        : { ...task, ...(updater || {}) };
+
+    return this.save(nextTask);
+  }
+
+  async appendHistory(id, event) {
+    return this.update(id, (task) => ({
+      ...task,
+      history: [
+        ...(Array.isArray(task.history) ? task.history : []),
+        {
+          time: nowIso(this.clock),
+          ...event
+        }
+      ]
+    }));
+  }
+
+  async appendMessage(id, role, content) {
+    return this.update(id, (task) => ({
+      ...task,
+      messages: [
+        ...(Array.isArray(task.messages) ? task.messages : []),
+        {
+          role,
+          content: String(content ?? ''),
+          time: nowIso(this.clock)
+        }
+      ]
+    }));
+  }
+
+  async delete(id) {
+    try {
+      await this.fs.rm(this.taskPath(id), { force: true });
+      await this.removeIndexEntry(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export default new TaskStore();