arisa 5.1.49 → 5.1.60

package/src/core/tasks/task-store.js

@@ -1,11 +1,39 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
 import { tasksFile } from "../../runtime/paths.js";
 
+const DEFAULT_RETRY = Object.freeze({
+  maxAttempts: 3,
+  baseDelaySeconds: 30,
+  maxDelaySeconds: 900,
+  multiplier: 2
+});
+
+const TERMINAL_STATUSES = new Set(["done", "failed", "outcome_uncertain"]);
+const TERMINAL_PAYLOAD_KEYS = ["chatId", "toolName", "resourceId", "artifactId"];
+
+const taskFileOperations = new Map();
+
+async function serializeTaskFileOperation(operation) {
+  const previous = taskFileOperations.get(tasksFile) || Promise.resolve();
+  const current = previous.catch(() => {}).then(operation);
+  taskFileOperations.set(tasksFile, current);
+  try {
+    return await current;
+  } finally {
+    if (taskFileOperations.get(tasksFile) === current) taskFileOperations.delete(tasksFile);
+  }
+}
+
+async function waitForTaskFileOperations() {
+  await (taskFileOperations.get(tasksFile) || Promise.resolve()).catch(() => {});
+}
+
 async function loadTasksFile() {
   try {
-    return JSON.parse(await readFile(tasksFile, "utf8"));
+    const parsed = JSON.parse(await readFile(tasksFile, "utf8"));
+    return Array.isArray(parsed) ? parsed.map(migrateTask) : [];
   } catch {
     return [];
   }
@@ -13,173 +41,369 @@ async function loadTasksFile() {
 
 async function saveTasksFile(tasks) {
   await mkdir(path.dirname(tasksFile), { recursive: true });
-  await writeFile(tasksFile, `${JSON.stringify(tasks, null, 2)}\n`, "utf8");
+  const temporaryFile = `${tasksFile}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    await writeFile(temporaryFile, `${JSON.stringify(tasks, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await rename(temporaryFile, tasksFile);
+  } finally {
+    await rm(temporaryFile, { force: true }).catch(() => {});
+  }
 }
 
 function taskId() {
   return crypto.randomUUID();
 }
 
-function normalizeTask(task, defaults = {}) {
+function boundedPositiveInteger(value, fallback, maximum) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? Math.min(parsed, maximum) : fallback;
+}
+
+function boundedPositiveNumber(value, fallback, maximum) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, maximum) : fallback;
+}
+
+function normalizeRetry(retry = {}) {
+  const value = retry && typeof retry === "object" && !Array.isArray(retry) ? retry : {};
+  return {
+    maxAttempts: boundedPositiveInteger(value.maxAttempts, DEFAULT_RETRY.maxAttempts, 10),
+    baseDelaySeconds: boundedPositiveNumber(value.baseDelaySeconds, DEFAULT_RETRY.baseDelaySeconds, 3_600),
+    maxDelaySeconds: boundedPositiveNumber(value.maxDelaySeconds, DEFAULT_RETRY.maxDelaySeconds, 86_400),
+    multiplier: boundedPositiveNumber(value.multiplier, DEFAULT_RETRY.multiplier, 10)
+  };
+}
+
+function legacyTelegramRoute(telegramContext) {
+  if (!telegramContext?.transportChatId) return null;
   return {
+    transport: "telegram",
+    destination: {
+      chatId: telegramContext.transportChatId,
+      ...(telegramContext.messageThreadId ? { threadId: telegramContext.messageThreadId } : {})
+    }
+  };
+}
+
+function migrateTask(task = {}) {
+  const payload = { ...(task.payload || {}) };
+  const route = task.route || legacyTelegramRoute(payload.telegramContext) || null;
+  delete payload.telegramContext;
+  const migrated = {
+    ...task,
+    payload,
+    route,
+    attempts: Number.isSafeInteger(task.attempts) && task.attempts >= 0 ? task.attempts : 0
+  };
+  if (!TERMINAL_STATUSES.has(migrated.status)) migrated.retry = normalizeRetry(task.retry);
+  return migrated;
+}
+
+function compactTerminalPayload(payload = {}) {
+  return Object.fromEntries(TERMINAL_PAYLOAD_KEYS.flatMap((key) => {
+    const value = payload[key];
+    return ["string", "number", "boolean"].includes(typeof value) ? [[key, value]] : [];
+  }));
+}
+
+function compactTerminalTask(task) {
+  if (!TERMINAL_STATUSES.has(task.status)) return false;
+  const payload = compactTerminalPayload(task.payload);
+  const changed = !task.payloadCompacted
+    || JSON.stringify(task.payload || {}) !== JSON.stringify(payload)
+    || Object.hasOwn(task, "retry")
+    || Object.hasOwn(task, "recurrence");
+  task.payload = payload;
+  task.payloadCompacted = true;
+  delete task.retry;
+  delete task.recurrence;
+  return changed;
+}
+
+function normalizeTask(task, defaults = {}) {
+  const mergedPayload = {
+    ...(defaults.payload || {}),
+    ...(task.payload || {})
+  };
+  const route = task.route
+    || defaults.route
+    || legacyTelegramRoute(mergedPayload.telegramContext)
+    || null;
+  delete mergedPayload.telegramContext;
+  const normalized = migrateTask({
     id: task.id || taskId(),
     status: task.status || "pending",
     createdAt: task.createdAt || new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     kind: task.kind,
     runAt: task.runAt || new Date().toISOString(),
-    payload: {
-      ...(defaults.payload || {}),
-      ...(task.payload || {})
-    },
+    payload: mergedPayload,
+    route,
     recurrence: task.recurrence || defaults.recurrence || null,
     source: {
       ...(defaults.source || {}),
       ...(task.source || {})
-    }
-  };
+    },
+    attempts: task.attempts || 0,
+    retry: task.retry || defaults.retry
+  });
+  compactTerminalTask(normalized);
+  return normalized;
 }
 
-function computeNextRunAt(task) {
+function computeNextRunAt(task, now = Date.now()) {
   if (task.recurrence?.type === "interval" && Number(task.recurrence.everySeconds) > 0) {
-    return new Date(Date.now() + (Number(task.recurrence.everySeconds) * 1000)).toISOString();
+    return new Date(now + (Number(task.recurrence.everySeconds) * 1000)).toISOString();
   }
   return "";
 }
 
+function retryDelayMs(task) {
+  const exponent = Math.max(0, Number(task.attempts || 1) - 1);
+  const seconds = Math.min(
+    task.retry.maxDelaySeconds,
+    task.retry.baseDelaySeconds * (task.retry.multiplier ** exponent)
+  );
+  return Math.max(1, Math.round(seconds * 1000));
+}
+
+function failTask(task, error) {
+  const failedAt = new Date().toISOString();
+  task.status = "failed";
+  task.error = error instanceof Error ? error.message : String(error);
+  task.lastError = task.error;
+  task.failedAt = failedAt;
+  task.updatedAt = failedAt;
+  compactTerminalTask(task);
+  return structuredClone(task);
+}
+
 export class TaskStore {
   constructor() {
     this.tasks = null;
   }
 
   async init() {
-    if (!this.tasks) this.tasks = await loadTasksFile();
+    if (!this.tasks) await this.reload();
   }
 
   async reload() {
+    await waitForTaskFileOperations();
     this.tasks = await loadTasksFile();
   }
 
+  async mutate(operation) {
+    return serializeTaskFileOperation(async () => {
+      this.tasks = await loadTasksFile();
+      const { result, changed = true } = await operation(this.tasks);
+      if (changed) await saveTasksFile(this.tasks);
+      return result;
+    });
+  }
+
   async save() {
-    await saveTasksFile(this.tasks || []);
+    const tasks = structuredClone(this.tasks || []);
+    return serializeTaskFileOperation(async () => {
+      this.tasks = tasks;
+      await saveTasksFile(tasks);
+    });
   }
 
   async add(task, defaults = {}) {
-    await this.init();
-    const normalized = normalizeTask(task, defaults);
-    this.tasks.push(normalized);
-    await this.save();
-    return normalized;
+    return this.mutate(async (tasks) => {
+      const normalized = normalizeTask(task, defaults);
+      tasks.push(normalized);
+      return { result: structuredClone(normalized) };
+    });
   }
 
-  async addMany(tasks = [], defaults = {}) {
-    const created = [];
-    for (const task of tasks) {
-      created.push(await this.add(task, defaults));
-    }
-    return created;
+  async addMany(tasksToAdd = [], defaults = {}) {
+    return this.mutate(async (tasks) => {
+      const created = tasksToAdd.map((task) => normalizeTask(task, defaults));
+      tasks.push(...created);
+      return { result: structuredClone(created), changed: created.length > 0 };
+    });
   }
 
   async claimDue(limit = 10) {
-    await this.reload();
-    const now = Date.now();
-    const due = [];
-
-    for (const task of this.tasks) {
-      if (due.length >= limit) break;
-      if (task.status !== "pending") continue;
-      if (!task.runAt || Number.isNaN(Date.parse(task.runAt))) continue;
-      if (Date.parse(task.runAt) > now) continue;
-      task.status = "running";
-      task.updatedAt = new Date().toISOString();
-      due.push({ ...task });
-    }
+    return this.mutate(async (tasks) => {
+      const now = Date.now();
+      const due = [];
 
-    if (due.length) await this.save();
-    return due;
+      for (const task of tasks) {
+        if (due.length >= limit) break;
+        if (task.status !== "pending") continue;
+        if (!task.runAt || Number.isNaN(Date.parse(task.runAt))) continue;
+        if (Date.parse(task.runAt) > now) continue;
+        task.status = "running";
+        task.attempts += 1;
+        task.startedAt = new Date(now).toISOString();
+        task.updatedAt = task.startedAt;
+        due.push(structuredClone(task));
+      }
+
+      return { result: due, changed: due.length > 0 };
+    });
   }
 
   async recoverInterrupted() {
-    await this.reload();
-    const recovered = [];
-    const updatedAt = new Date().toISOString();
+    return this.mutate(async (tasks) => {
+      const recovered = [];
+      let compacted = false;
+      const now = Date.now();
 
-    for (const task of this.tasks) {
-      if (task.status !== "running") continue;
-      task.status = "pending";
-      task.updatedAt = updatedAt;
-      recovered.push({ ...task });
-    }
+      for (const task of tasks) {
+        if (task.status === "running") {
+          const interruptedAt = new Date(now).toISOString();
+          task.lastError = "execution interrupted before confirmation";
+          task.lastFailedAt = interruptedAt;
+          task.updatedAt = interruptedAt;
+          if (task.kind === "poll_tool") {
+            task.status = "pending";
+            task.runAt = new Date(now + retryDelayMs(task)).toISOString();
+          } else {
+            const nextRunAt = computeNextRunAt(task, now);
+            if (nextRunAt) {
+              task.status = "pending";
+              task.runAt = nextRunAt;
+              task.attempts = 0;
+              task.lastOutcome = "outcome_uncertain";
+            } else {
+              task.status = "outcome_uncertain";
+              task.error = task.lastError;
+            }
+          }
+          compactTerminalTask(task);
+          recovered.push(structuredClone(task));
+          continue;
+        }
+        if (compactTerminalTask(task)) compacted = true;
+      }
 
-    if (recovered.length) await this.save();
-    return recovered;
+      return { result: recovered, changed: recovered.length > 0 || compacted };
+    });
   }
 
   async complete(taskId) {
-    await this.init();
-    const task = this.tasks.find((item) => item.id === taskId);
-    if (!task) return null;
+    return this.mutate(async (tasks) => {
+      const task = tasks.find((item) => item.id === taskId);
+      if (!task) return { result: null, changed: false };
 
-    const nextRunAt = computeNextRunAt(task);
-    if (nextRunAt) {
+      const now = Date.now();
+      const completedAt = new Date(now).toISOString();
+      const nextRunAt = computeNextRunAt(task, now);
+      task.lastCompletedAt = completedAt;
+      task.lastRunAt = completedAt;
+      delete task.lastError;
+      delete task.error;
+      delete task.lastOutcome;
+      delete task.consecutiveFailures;
+      if (nextRunAt) {
+        task.status = "pending";
+        task.runAt = nextRunAt;
+        task.attempts = 0;
+        delete task.startedAt;
+      } else {
+        task.status = "done";
+        task.completedAt = completedAt;
+      }
+      task.updatedAt = completedAt;
+      compactTerminalTask(task);
+      return { result: structuredClone(task) };
+    });
+  }
+
+  async retryOrFail(taskId, error, { retryable = true, outcomeUncertain = false } = {}) {
+    return this.mutate(async (tasks) => {
+      const task = tasks.find((item) => item.id === taskId);
+      if (!task) return { result: null, changed: false };
+      const message = error instanceof Error ? error.message : String(error);
+      if (outcomeUncertain) {
+        const uncertainAt = new Date().toISOString();
+        task.status = "outcome_uncertain";
+        task.error = message;
+        task.lastError = message;
+        task.uncertainAt = uncertainAt;
+        task.updatedAt = uncertainAt;
+        compactTerminalTask(task);
+        return { result: structuredClone(task) };
+      }
+      if (!retryable) return { result: failTask(task, message) };
+      if (task.attempts >= task.retry.maxAttempts) {
+        const now = Date.now();
+        const nextRunAt = computeNextRunAt(task, now);
+        if (!nextRunAt) return { result: failTask(task, message) };
+
+        const failedAt = new Date(now).toISOString();
+        task.status = "pending";
+        task.runAt = nextRunAt;
+        task.attempts = 0;
+        task.lastOutcome = "failed";
+        task.lastError = message;
+        task.lastFailedAt = failedAt;
+        task.consecutiveFailures = Number(task.consecutiveFailures || 0) + 1;
+        task.updatedAt = failedAt;
+        delete task.startedAt;
+        delete task.error;
+        return { result: { ...structuredClone(task), terminalFailure: true } };
+      }
+
+      const now = Date.now();
       task.status = "pending";
-      task.runAt = nextRunAt;
-      task.lastRunAt = new Date().toISOString();
-    } else {
-      task.status = "done";
-      task.completedAt = new Date().toISOString();
-    }
-    task.updatedAt = new Date().toISOString();
-    await this.save();
-    return task;
+      task.runAt = new Date(now + retryDelayMs(task)).toISOString();
+      task.lastError = message;
+      task.lastFailedAt = new Date(now).toISOString();
+      task.updatedAt = task.lastFailedAt;
+      return { result: structuredClone(task) };
+    });
   }
 
   async fail(taskId, error) {
-    await this.init();
-    const task = this.tasks.find((item) => item.id === taskId);
-    if (!task) return null;
-    task.status = "failed";
-    task.error = error;
-    task.updatedAt = new Date().toISOString();
-    await this.save();
-    return task;
+    return this.mutate(async (tasks) => {
+      const task = tasks.find((item) => item.id === taskId);
+      return task
+        ? { result: failTask(task, error) }
+        : { result: null, changed: false };
+    });
   }
 
   async list(filter = {}) {
     await this.reload();
     return this.tasks.filter((task) => {
-      if (filter.chatId && task.payload?.chatId !== filter.chatId) return false;
+      if (filter.chatId && String(task.payload?.chatId) !== String(filter.chatId)) return false;
       if (filter.status && task.status !== filter.status) return false;
       if (filter.kind && task.kind !== filter.kind) return false;
       return true;
-    });
+    }).map((task) => structuredClone(task));
   }
 
   async get(taskId) {
     await this.reload();
-    return this.tasks.find((item) => item.id === taskId) || null;
+    const task = this.tasks.find((item) => item.id === taskId);
+    return task ? structuredClone(task) : null;
   }
 
   async cancel(taskId) {
-    await this.reload();
-    const index = this.tasks.findIndex((item) => item.id === taskId);
-    if (index === -1) return null;
-    const [task] = this.tasks.splice(index, 1);
-    await this.save();
-    return task;
+    return this.mutate(async (tasks) => {
+      const index = tasks.findIndex((item) => item.id === taskId);
+      if (index === -1) return { result: null, changed: false };
+      const [task] = tasks.splice(index, 1);
+      return { result: structuredClone(task) };
+    });
   }
 
   async cancelAll(filter = {}) {
-    await this.reload();
-    const removed = [];
-    this.tasks = this.tasks.filter((task) => {
-      if (filter.chatId && task.payload?.chatId !== filter.chatId) return true;
-      if (filter.status && task.status !== filter.status) return true;
-      if (task.status === "done" || task.status === "failed") return true;
-      removed.push({ ...task });
-      return false;
+    return this.mutate(async (tasks) => {
+      const removed = [];
+      const remaining = tasks.filter((task) => {
+        if (filter.chatId && String(task.payload?.chatId) !== String(filter.chatId)) return true;
+        if (filter.status && task.status !== filter.status) return true;
+        if (["done", "failed", "outcome_uncertain"].includes(task.status)) return true;
+        removed.push(structuredClone(task));
+        return false;
+      });
+      tasks.splice(0, tasks.length, ...remaining);
+      return { result: removed, changed: removed.length > 0 };
     });
-    if (removed.length) await this.save();
-    return removed;
   }
 }

package/src/core/tools/tool-output-materializer.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { unlink } from "node:fs/promises";
+import { taskWithoutCallerRouting } from "../tasks/task-routing.js";
 
 export async function materializeToolOutput({ result, name, chatId, artifactStore, taskStore, taskContext = null }) {
   const chatArtifactStore = artifactStore.forChat(chatId);
@@ -27,11 +28,10 @@ export async function materializeToolOutput({ result, name, chatId, artifactStor
   }
 
   if (result.asyncTask || result.asyncTasks?.length) {
-    result.asyncTasks = await taskStore.addMany(result.asyncTasks || [result.asyncTask], {
-      payload: {
-        chatId,
-        ...(taskContext ? { telegramContext: taskContext } : {})
-      },
+    const requestedTasks = (result.asyncTasks || [result.asyncTask]).map(taskWithoutCallerRouting);
+    result.asyncTasks = await taskStore.addMany(requestedTasks, {
+      payload: { chatId },
+      ...(taskContext ? { route: taskContext } : {}),
       source: { type: "tool", toolName: name, chatId }
     });
     delete result.asyncTask;

package/src/official-tools.lock.json

@@ -1,7 +1,7 @@
 {
   "version": 1,
   "repository": "https://github.com/clasen/Arisa.git",
-  "commit": "aaec12e4f63f4959462b26380e7d4c1a60562586",
+  "commit": "43b032cbaa5e4ec42345a822119f06a13f49ff8f",
   "tools": {
     "browser-session-bridge": {
       "version": "0.1.0",
@@ -96,12 +96,14 @@
       }
     },
     "master-slave": {
+      "version": "0.1.2",
       "files": {
-        "README.md": "84d2841d8df31c07065d4fee6e434dc43cad241f3abf63e95efafad51ed69fcb",
+        "README.md": "9755dd59d01680236d12b57f87e4bc52568649a0e63b1a96065baf800d8dc1c8",
         "batch-runner.js": "97756a03b36278cd0315cc16da0c34a7821c322149c51ba6666f1c5081dbecbc",
         "chat-state-store.js": "50de39aa33432733bb688eb01968e314a32b169324a66d0f0089b2a19ed9c880",
+        "command-arguments.js": "ef00f814dee6105e1cd3b8929e974bc071117f162b17e3dcc3dc0ea68e8b1e92",
         "config.js": "ff1c1cb6701ae1da7a6eb1519ba96a416e48daa73c2155a6f93cf5d64f65cef8",
-        "index.js": "8586303b3d1bf937932159adbe9b69c1031e6a393300e7d3aca93910ddfab082",
+        "index.js": "404db150dee0ecf79cd64bca245c618fa1e2bb324d6bc15f5ac0022b72497c63",
         "lib/bootstrap-url.js": "f05925cc0f0dff0882f94f9908c6f2c80aa8632cd51f63389381dcbb0f73afb3",
         "lib/encrypted-frames.js": "47e1b11fafdbbcdfd86a0993a47a774e4f37d6386edeaf8ec1c8511b109728cf",
         "lib/handshake-crypto.js": "9728b117aad7de53f5f0e255c0fd865ee1a19633368730a7634334d374094578",
@@ -111,12 +113,13 @@
         "lib/secure-store.js": "b8f365197f8e60d7f81fde6ed1cfc8851b603f6b0783e4cdc9036bb5c99726e1",
         "master-domain.js": "10b7dfb43eb9939eb5baec54f742076cc73a2add6589a0ff57c51bc79c236faf",
         "network-session.js": "db2d81a7ef47af29236d963b98e21414a11fef68e8b20895126eaad3f696ba3d",
-        "package.json": "ef4824ccb46ddb3f901dd6e7a94abbd458152a2e73292ec409470643f45ff396",
+        "package.json": "1f37665b860b7f2f5b37cc931dcc9c4ac4fb82d1260fc14c0646fa4d92ade0b3",
         "remote-runtime.js": "55dd7e577a822be17c2f337798a2d7f44ad0c5b6d68c46490e058282135c4658",
         "slave-operations.js": "fec2e8addfff98f080284f24f722c1516124e5f6d12d8c03bb3c9cc0c475d1d6",
         "state-store.js": "c56849a3f1b9c990128276e17963034a7836abacedc44f2e500d5732ebf9e451",
         "test/batch-runner.test.js": "69f69150eadd18c1ad1bc54f429e6cb5bc0c4492e3c6a6e76c2ce6827780ae41",
         "test/bootstrap-url.test.js": "62c112b1a38c59ea2c77f797e32873667b52db32386da661a6ae8410490126fe",
+        "test/command-arguments.test.js": "360c087edd0a589b28111bb82d06e3e73e93a6b22da0a57cb96f0a7e92a9bd5f",
         "test/encrypted-frames.test.js": "cfb3195d3a58df7dc570bc7840a21c1841a53e0abc8b92840e0c24ed3435bcc1",
         "test/handshake-crypto.test.js": "f11d6e95658f2055d8256bd7dfb66b39bedf95bf62a3cec5525b109bb6f9bc95",
         "test/master-domain.test.js": "7298766db3e6b186cca0109f352766e1bf417a8af12a58dd1c2b78fd1a61ff24",