opencode-supertask 0.1.21 → 0.1.23

package/dist/web/index.js

@@ -7247,26 +7247,26 @@ var require_CronDate = __commonJS({
        * @param {CronDate | Date | number | string} [timestamp] - The timestamp to initialize the CronDate with.
        * @param {string} [tz] - The timezone to use for the CronDate.
        */
-      constructor(timestamp, tz) {
+      constructor(timestamp2, tz) {
         const dateOpts = { zone: tz };
-        if (!timestamp) {
+        if (!timestamp2) {
           this.#date = luxon_1.DateTime.local();
-        } else if (timestamp instanceof _CronDate) {
-          this.#date = timestamp.#date;
-          this.#dstStart = timestamp.#dstStart;
-          this.#dstEnd = timestamp.#dstEnd;
-        } else if (timestamp instanceof Date) {
-          this.#date = luxon_1.DateTime.fromJSDate(timestamp, dateOpts);
-        } else if (typeof timestamp === "number") {
-          this.#date = luxon_1.DateTime.fromMillis(timestamp, dateOpts);
+        } else if (timestamp2 instanceof _CronDate) {
+          this.#date = timestamp2.#date;
+          this.#dstStart = timestamp2.#dstStart;
+          this.#dstEnd = timestamp2.#dstEnd;
+        } else if (timestamp2 instanceof Date) {
+          this.#date = luxon_1.DateTime.fromJSDate(timestamp2, dateOpts);
+        } else if (typeof timestamp2 === "number") {
+          this.#date = luxon_1.DateTime.fromMillis(timestamp2, dateOpts);
         } else {
-          this.#date = luxon_1.DateTime.fromISO(timestamp, dateOpts);
-          this.#date.isValid || (this.#date = luxon_1.DateTime.fromRFC2822(timestamp, dateOpts));
-          this.#date.isValid || (this.#date = luxon_1.DateTime.fromSQL(timestamp, dateOpts));
-          this.#date.isValid || (this.#date = luxon_1.DateTime.fromFormat(timestamp, "EEE, d MMM yyyy HH:mm:ss", dateOpts));
+          this.#date = luxon_1.DateTime.fromISO(timestamp2, dateOpts);
+          this.#date.isValid || (this.#date = luxon_1.DateTime.fromRFC2822(timestamp2, dateOpts));
+          this.#date.isValid || (this.#date = luxon_1.DateTime.fromSQL(timestamp2, dateOpts));
+          this.#date.isValid || (this.#date = luxon_1.DateTime.fromFormat(timestamp2, "EEE, d MMM yyyy HH:mm:ss", dateOpts));
         }
         if (!this.#date.isValid) {
-          throw new Error(`CronDate: unhandled timestamp: ${timestamp}`);
+          throw new Error(`CronDate: unhandled timestamp: ${timestamp2}`);
         }
         if (tz && tz !== this.#date.zoneName) {
           this.#date = this.#date.setZone(tz);
@@ -16650,6 +16650,14 @@ function getSqlite() {
   if (!_sqlite) initDb();
   return _sqlite;
 }
+function closeDb() {
+  if (_sqlite) {
+    _sqlite.close();
+    _sqlite = null;
+    _db = null;
+    _migrationRan = false;
+  }
+}
 var db = new Proxy({}, {
   get(_, prop) {
     const target = getDb();
@@ -16840,6 +16848,23 @@ var TaskService = class {
     ).returning();
     return result.length;
   }
+  static async resetOrphanRunningToPending() {
+    const result = await db.update(tasks2).set({
+      status: "pending",
+      startedAt: null,
+      finishedAt: null
+    }).where(
+      and(
+        eq(tasks2.status, "running"),
+        sql`NOT EXISTS (
+                        SELECT 1 FROM ${taskRuns2}
+                        WHERE ${taskRuns2.taskId} = ${tasks2.id}
+                          AND ${taskRuns2.status} = 'running'
+                    )`
+      )
+    ).returning();
+    return result.length;
+  }
   static async cancel(id, scope = {}) {
     const conditions = [
       eq(tasks2.id, id),
@@ -17190,8 +17215,345 @@ var TaskTemplateService = class {
   }
 };
 
+// src/core/services/database-maintenance.service.ts
+import { Database as Database3 } from "bun:sqlite";
+import { randomUUID } from "crypto";
+import {
+  chmodSync,
+  constants,
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { basename, dirname as dirname2, resolve } from "path";
+
+// src/core/process-control.ts
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+
+// src/core/services/database-maintenance.service.ts
+var REQUIRED_TABLES = ["gateway_lock", "tasks", "task_runs", "task_templates"];
+var DatabaseMaintenanceConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DatabaseMaintenanceConflictError";
+  }
+};
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function normalizedPath(path) {
+  return path === ":memory:" ? path : resolve(path);
+}
+function safeUnlink(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? error.code : void 0;
+    if (code !== "ENOENT") throw error;
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var DatabaseMaintenanceService = class {
+  static check() {
+    return this.inspect(getSqlite(), DB_FILE_PATH);
+  }
+  static backup(outputPath) {
+    const sqlite2 = getSqlite();
+    try {
+      sqlite2.query("PRAGMA wal_checkpoint(PASSIVE)").get();
+    } catch {
+    }
+    return this.writeSnapshot(sqlite2, outputPath ?? this.createBackupPath("backup"));
+  }
+  static clear(options = {}) {
+    const sqlite2 = getSqlite();
+    this.assertGatewaySafe(sqlite2, options.allowCurrentGateway ?? false);
+    this.assertNoRunningWork(sqlite2);
+    sqlite2.exec("BEGIN IMMEDIATE");
+    let backup = null;
+    try {
+      this.assertGatewaySafe(sqlite2, options.allowCurrentGateway ?? false);
+      this.assertNoRunningWork(sqlite2);
+      const before = this.readCounts(sqlite2);
+      backup = this.writeSnapshot(sqlite2, this.createBackupPath("pre-clear"));
+      sqlite2.exec("DELETE FROM task_runs");
+      sqlite2.exec("DELETE FROM tasks");
+      sqlite2.exec("DELETE FROM task_templates");
+      sqlite2.exec("COMMIT");
+      return {
+        backupPath: backup.path,
+        deleted: before,
+        check: this.inspect(sqlite2, DB_FILE_PATH)
+      };
+    } catch (error) {
+      if (sqlite2.inTransaction) sqlite2.exec("ROLLBACK");
+      if (error instanceof DatabaseMaintenanceConflictError) throw error;
+      const backupHint = backup ? `\uFF1B\u4E8B\u52A1\u5DF2\u56DE\u6EDA\uFF0C\u5907\u4EFD\u4FDD\u7559\u5728 ${backup.path}` : "";
+      throw new Error(`\u6E05\u7A7A\u6570\u636E\u5E93\u5931\u8D25${backupHint}\uFF1A${errorMessage(error)}`);
+    }
+  }
+  static restore(sourcePath) {
+    if (DB_FILE_PATH === ":memory:") {
+      throw new Error("\u5185\u5B58\u6570\u636E\u5E93\u4E0D\u652F\u6301 restore");
+    }
+    const source = normalizedPath(sourcePath);
+    const livePath = normalizedPath(DB_FILE_PATH);
+    if (source === livePath) throw new Error("\u6062\u590D\u6765\u6E90\u4E0D\u80FD\u662F\u5F53\u524D\u6570\u636E\u5E93\u6587\u4EF6");
+    const current = getSqlite();
+    this.assertGatewaySafe(current, false);
+    this.assertNoRunningWork(current);
+    if (!existsSync2(source) || !statSync(source).isFile()) {
+      throw new Error(`\u5907\u4EFD\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${source}`);
+    }
+    let sourceCheck;
+    try {
+      sourceCheck = this.inspectFile(source);
+    } catch (error) {
+      throw new Error(`\u5907\u4EFD\u6587\u4EF6\u65E0\u6548\uFF1A${errorMessage(error)}`);
+    }
+    if (!sourceCheck.ok) {
+      throw new Error(`\u5907\u4EFD\u6587\u4EF6\u6821\u9A8C\u5931\u8D25\uFF1A${sourceCheck.integrityMessages.join("; ") || "schema/foreign key error"}`);
+    }
+    const stagePath = `${livePath}.restore-${process.pid}-${randomUUID()}.tmp`;
+    const rollbackPath = `${livePath}.rollback-${process.pid}-${randomUUID()}.tmp`;
+    let safetyBackup = null;
+    let liveMoved = false;
+    try {
+      copyFileSync(source, stagePath, constants.COPYFILE_EXCL);
+      chmodSync(stagePath, 384);
+      const staged = new Database3(stagePath);
+      try {
+        const stagedCheck = this.inspect(staged, stagePath);
+        if (!stagedCheck.ok) throw new Error("\u6682\u5B58\u6062\u590D\u6587\u4EF6\u6821\u9A8C\u5931\u8D25");
+        const now = Date.now();
+        staged.query(
+          "INSERT OR REPLACE INTO gateway_lock (id, pid, acquired_at, heartbeat_at, ready_at) VALUES (1, ?, ?, ?, NULL)"
+        ).run(process.pid, now, now);
+      } finally {
+        staged.close();
+      }
+      const sqlite2 = getSqlite();
+      sqlite2.exec("BEGIN IMMEDIATE");
+      try {
+        this.assertGatewaySafe(sqlite2, false);
+        this.assertNoRunningWork(sqlite2);
+        safetyBackup = this.writeSnapshot(sqlite2, this.createBackupPath("pre-restore"));
+        const now = Date.now();
+        sqlite2.query(
+          "INSERT OR REPLACE INTO gateway_lock (id, pid, acquired_at, heartbeat_at, ready_at) VALUES (1, ?, ?, ?, NULL)"
+        ).run(process.pid, now, now);
+        sqlite2.exec("COMMIT");
+      } catch (error) {
+        if (sqlite2.inTransaction) sqlite2.exec("ROLLBACK");
+        throw error;
+      }
+      const checkpoint = sqlite2.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      if (checkpoint && checkpoint.busy !== 0) {
+        throw new DatabaseMaintenanceConflictError("\u6570\u636E\u5E93\u4ECD\u88AB\u5176\u4ED6\u8FDE\u63A5\u5360\u7528\uFF0C\u65E0\u6CD5\u5B89\u5168\u6062\u590D");
+      }
+      closeDb();
+      safeUnlink(`${livePath}-wal`);
+      safeUnlink(`${livePath}-shm`);
+      renameSync(livePath, rollbackPath);
+      liveMoved = true;
+      renameSync(stagePath, livePath);
+      const restored = getSqlite();
+      restored.exec("BEGIN IMMEDIATE");
+      let recoveredRunningTasks = 0;
+      let closedRunningRuns = 0;
+      try {
+        recoveredRunningTasks = this.scalar(
+          restored,
+          "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'"
+        );
+        closedRunningRuns = this.scalar(
+          restored,
+          "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'"
+        );
+        const finishedAt = Math.floor(Date.now() / 1e3);
+        restored.query(`
+                    UPDATE task_runs
+                    SET status = 'failed', finished_at = ?,
+                        log = CASE
+                            WHEN log IS NULL OR log = '' THEN '\u6570\u636E\u5E93\u6062\u590D\u65F6\u5173\u95ED\u9057\u7559\u8FD0\u884C\u8BB0\u5F55'
+                            ELSE log || '
+\u6570\u636E\u5E93\u6062\u590D\u65F6\u5173\u95ED\u9057\u7559\u8FD0\u884C\u8BB0\u5F55'
+                        END
+                    WHERE status = 'running'
+                `).run(finishedAt);
+        restored.exec(`
+                    UPDATE tasks
+                    SET status = 'pending', started_at = NULL, finished_at = NULL
+                    WHERE status = 'running'
+                `);
+        restored.query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+        restored.exec("COMMIT");
+      } catch (error) {
+        if (restored.inTransaction) restored.exec("ROLLBACK");
+        throw error;
+      }
+      const check = this.inspect(restored, livePath);
+      if (!check.ok) throw new Error("\u6062\u590D\u540E\u7684\u6570\u636E\u5E93\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C");
+      safeUnlink(rollbackPath);
+      return {
+        sourcePath: source,
+        safetyBackupPath: safetyBackup.path,
+        recoveredRunningTasks,
+        closedRunningRuns,
+        check
+      };
+    } catch (error) {
+      closeDb();
+      safeUnlink(`${livePath}-wal`);
+      safeUnlink(`${livePath}-shm`);
+      safeUnlink(stagePath);
+      safeUnlink(`${stagePath}-journal`);
+      safeUnlink(`${stagePath}-wal`);
+      safeUnlink(`${stagePath}-shm`);
+      if (liveMoved && existsSync2(rollbackPath)) {
+        safeUnlink(livePath);
+        renameSync(rollbackPath, livePath);
+        try {
+          const original = getSqlite();
+          original.query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+        } catch {
+        }
+      } else if (existsSync2(rollbackPath)) {
+        safeUnlink(rollbackPath);
+      } else {
+        try {
+          getSqlite().query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+        } catch {
+        }
+      }
+      const backupHint = safetyBackup ? `\uFF1B\u5F53\u524D\u5E93\u5B89\u5168\u5907\u4EFD\uFF1A${safetyBackup.path}` : "";
+      throw new Error(`\u6062\u590D\u6570\u636E\u5E93\u5931\u8D25\uFF0C\u5DF2\u5C1D\u8BD5\u56DE\u6EDA${backupHint}\uFF1A${errorMessage(error)}`);
+    }
+  }
+  static inspectFile(path) {
+    let sqlite2;
+    try {
+      sqlite2 = new Database3(path, { readonly: true, strict: true });
+    } catch (error) {
+      throw new Error(`\u65E0\u6CD5\u6253\u5F00\u5907\u4EFD\u6587\u4EF6\uFF1A${errorMessage(error)}`);
+    }
+    try {
+      return this.inspect(sqlite2, path);
+    } finally {
+      sqlite2.close();
+    }
+  }
+  static inspect(sqlite2, path) {
+    const tableRows = sqlite2.query(
+      "SELECT name FROM sqlite_master WHERE type = 'table'"
+    ).all();
+    const tableNames = new Set(tableRows.map((row) => row.name));
+    const missingTables = REQUIRED_TABLES.filter((table) => !tableNames.has(table));
+    const integrityRows = sqlite2.query("PRAGMA integrity_check").all();
+    const integrityMessages = integrityRows.map((row) => row.integrity_check);
+    const foreignKeyViolations = sqlite2.query("PRAGMA foreign_key_check").all().length;
+    const journal = sqlite2.query("PRAGMA journal_mode").get();
+    const counts = missingTables.length === 0 ? this.readCounts(sqlite2) : { tasks: 0, taskRuns: 0, taskTemplates: 0 };
+    const runningTasks = missingTables.includes("tasks") ? 0 : this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'");
+    const runningRuns = missingTables.includes("task_runs") ? 0 : this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'");
+    const sizeBytes = path === ":memory:" || !existsSync2(path) ? sqlite2.serialize().byteLength : statSync(path).size;
+    return {
+      ok: integrityMessages.length === 1 && integrityMessages[0] === "ok" && foreignKeyViolations === 0 && missingTables.length === 0,
+      path: normalizedPath(path),
+      sizeBytes,
+      journalMode: journal?.journal_mode ?? "unknown",
+      integrityMessages,
+      foreignKeyViolations,
+      missingTables,
+      counts,
+      runningTasks,
+      runningRuns
+    };
+  }
+  static writeSnapshot(sqlite2, outputPath) {
+    const liveCheck = this.inspect(sqlite2, DB_FILE_PATH);
+    if (!liveCheck.ok) throw new Error("\u5F53\u524D\u6570\u636E\u5E93\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C\uFF0C\u5DF2\u62D2\u7EDD\u521B\u5EFA\u5907\u4EFD");
+    const output = normalizedPath(outputPath);
+    if (DB_FILE_PATH !== ":memory:" && output === normalizedPath(DB_FILE_PATH)) {
+      throw new Error("\u5907\u4EFD\u8DEF\u5F84\u4E0D\u80FD\u8986\u76D6\u5F53\u524D\u6570\u636E\u5E93");
+    }
+    if (existsSync2(output)) throw new Error(`\u5907\u4EFD\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${output}`);
+    mkdirSync2(dirname2(output), { recursive: true });
+    const temporary = `${output}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+      writeFileSync(temporary, sqlite2.serialize(), { flag: "wx", mode: 384 });
+      const standalone = new Database3(temporary, { readwrite: true, create: false });
+      try {
+        standalone.query("PRAGMA journal_mode = DELETE").get();
+      } finally {
+        standalone.close();
+      }
+      safeUnlink(`${temporary}-wal`);
+      safeUnlink(`${temporary}-shm`);
+      const check = this.inspectFile(temporary);
+      if (!check.ok) throw new Error("\u65B0\u5907\u4EFD\u672A\u901A\u8FC7\u5B8C\u6574\u6027\u6821\u9A8C");
+      renameSync(temporary, output);
+      const finalCheck = { ...check, path: output, sizeBytes: statSync(output).size };
+      return { path: output, sizeBytes: finalCheck.sizeBytes, check: finalCheck };
+    } catch (error) {
+      safeUnlink(temporary);
+      safeUnlink(`${temporary}-wal`);
+      safeUnlink(`${temporary}-shm`);
+      throw error;
+    }
+  }
+  static createBackupPath(kind) {
+    const directory = DB_FILE_PATH === ":memory:" ? tmpdir() : dirname2(normalizedPath(DB_FILE_PATH));
+    const base = DB_FILE_PATH === ":memory:" ? "supertask-memory" : basename(DB_FILE_PATH, ".db");
+    return resolve(directory, `${base}.${kind}-${timestamp()}-${randomUUID().slice(0, 8)}.db`);
+  }
+  static readCounts(sqlite2) {
+    return {
+      tasks: this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM tasks"),
+      taskRuns: this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_runs"),
+      taskTemplates: this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_templates")
+    };
+  }
+  static scalar(sqlite2, statement) {
+    const row = sqlite2.query(statement).get();
+    return Number(row?.count ?? 0);
+  }
+  static assertGatewaySafe(sqlite2, allowCurrentGateway) {
+    const lock = sqlite2.query("SELECT pid FROM gateway_lock WHERE id = 1").get();
+    if (!lock || !isProcessAlive(lock.pid)) return;
+    if (allowCurrentGateway && lock.pid === process.pid) return;
+    throw new DatabaseMaintenanceConflictError(
+      `Gateway PID ${lock.pid} \u4ECD\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u6267\u884C pm2 stop supertask-gateway`
+    );
+  }
+  static assertNoRunningWork(sqlite2) {
+    const runningTasks = this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM tasks WHERE status = 'running'");
+    const runningRuns = this.scalar(sqlite2, "SELECT COUNT(*) AS count FROM task_runs WHERE status = 'running'");
+    if (runningTasks > 0 || runningRuns > 0) {
+      throw new DatabaseMaintenanceConflictError(
+        `\u5B58\u5728\u8FD0\u884C\u4E2D\u4EFB\u52A1\uFF08tasks=${runningTasks}, task_runs=${runningRuns}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u5371\u9669\u64CD\u4F5C`
+      );
+    }
+  }
+};
+
 // src/gateway/config.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 var DEFAULT_CONFIG = {
@@ -17296,7 +17658,7 @@ function validateConfig(input) {
   };
 }
 function loadConfig(path = getConfigPath()) {
-  if (!existsSync2(path)) return validateConfig({ configVersion: 2 });
+  if (!existsSync3(path)) return validateConfig({ configVersion: 2 });
   try {
     return validateConfig(JSON.parse(readFileSync(path, "utf-8")));
   } catch (error) {
@@ -17306,8 +17668,8 @@ function loadConfig(path = getConfigPath()) {
 }
 
 // src/web/index.tsx
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, renameSync } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "fs";
+import { dirname as dirname3 } from "path";
 
 // src/gateway/health.ts
 var LOCK_STALE_MS = 3e4;
@@ -17459,7 +17821,7 @@ function esc(s) {
 }
 function readCurrentConfig() {
   const configPath = getConfigPath();
-  if (!existsSync3(configPath)) return {};
+  if (!existsSync4(configPath)) return {};
   try {
     return JSON.parse(readFileSync2(configPath, "utf-8"));
   } catch {
@@ -17468,11 +17830,11 @@ function readCurrentConfig() {
 }
 function writeConfig(cfg) {
   const configPath = getConfigPath();
-  const dir = dirname2(configPath);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = dirname3(configPath);
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
   const tempPath = `${configPath}.${process.pid}.tmp`;
-  writeFileSync(tempPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
-  renameSync(tempPath, configPath);
+  writeFileSync2(tempPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+  renameSync2(tempPath, configPath);
 }
 var SHARED_STYLES = html`
 <style>
@@ -17564,12 +17926,12 @@ async function triggerTmpl(id){if(!confirm('\u7ACB\u5373\u89E6\u53D1\u4E00\u6B21
 function toggleLog(id){const el=document.getElementById('log-'+id);el.style.display=el.style.display==='none'?'block':'none';}
 
 async function clearDatabase(){
-  if(!confirm('\u786E\u5B9A\u6E05\u7A7A\u6240\u6709\u4EFB\u52A1\u6570\u636E\uFF1F\u6B64\u64CD\u4F5C\u4E0D\u53EF\u6062\u590D\uFF01'))return;
-  if(!confirm('\u518D\u6B21\u786E\u8BA4\uFF1A\u5C06\u5220\u9664\u6240\u6709\u4EFB\u52A1\u3001\u6267\u884C\u8BB0\u5F55\u548C\u8C03\u5EA6\u6A21\u677F\u3002'))return;
+  if(!confirm('\u786E\u5B9A\u6E05\u7A7A\u6240\u6709\u4EFB\u52A1\u6570\u636E\uFF1F\u7CFB\u7EDF\u4F1A\u5148\u81EA\u52A8\u521B\u5EFA\u5907\u4EFD\u3002'))return;
+  if(!confirm('\u518D\u6B21\u786E\u8BA4\uFF1A\u5C06\u4E8B\u52A1\u6027\u5220\u9664\u6240\u6709\u4EFB\u52A1\u3001\u6267\u884C\u8BB0\u5F55\u548C\u8C03\u5EA6\u6A21\u677F\u3002'))return;
   try{
-    const r=await fetch('/api/database/clear',{method:'POST'});
+    const r=await fetch('/api/database/clear',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({confirmation:'CLEAR'})});
     const d=await r.json();
-    if(d.success){alert('\u6570\u636E\u5E93\u5DF2\u6E05\u7A7A');location.reload();}
+    if(d.success){alert('\u6570\u636E\u5E93\u5DF2\u6E05\u7A7A\uFF0C\u81EA\u52A8\u5907\u4EFD\uFF1A'+d.backupPath);location.reload();}
     else{alert('\u6E05\u7A7A\u5931\u8D25: '+d.error);}
   }catch(e){alert('\u6E05\u7A7A\u5931\u8D25: '+e.message);}
 }
@@ -17810,7 +18172,7 @@ app.get("/system", async (c) => {
   const stats = await TaskService.stats({});
   const runningRuns = await TaskRunService.getAllRunningRuns();
   const templates = await TaskTemplateService.list(100);
-  const configExists = existsSync3(configPath);
+  const configExists = existsSync4(configPath);
   let runRows = "";
   if (runningRuns.length > 0) {
     for (const run of runningRuns) {
@@ -17884,7 +18246,7 @@ app.get("/system", async (c) => {
 
       <div class="card mt16" style="border-color:var(--red)">
         <h3 style="margin:0 0 12px;font-size:14px;color:var(--red)">\u5371\u9669\u64CD\u4F5C</h3>
-        <p class="sm mu" style="margin:0 0 12px">\u6E05\u7A7A\u6240\u6709\u4EFB\u52A1\u6570\u636E\uFF08tasks + task_runs + task_templates\uFF09\uFF0C\u4E0D\u53EF\u6062\u590D\u3002</p>
+        <p class="sm mu" style="margin:0 0 12px">\u81EA\u52A8\u5907\u4EFD\u540E\u4E8B\u52A1\u6027\u6E05\u7A7A tasks\u3001task_runs \u548C task_templates\uFF1B\u5B58\u5728\u8FD0\u884C\u4E2D\u4EFB\u52A1\u65F6\u4F1A\u62D2\u7EDD\u6267\u884C\u3002</p>
         <button class="btn btn-danger" style="border-color:var(--red);color:var(--red);padding:6px 16px" onclick="clearDatabase()">\u6E05\u7A7A\u6570\u636E\u5E93</button>
       </div>`;
   return c.html(renderLayout("\u7CFB\u7EDF\u72B6\u6001", "system", body));
@@ -17989,14 +18351,16 @@ app.put("/api/config", async (c) => {
   }
 });
 app.post("/api/database/clear", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (body.confirmation !== "CLEAR") {
+    return c.json({ success: false, error: "confirmation must be CLEAR" }, 400);
+  }
   try {
-    const { tasks: tasks3, taskRuns: taskRuns4, taskTemplates: taskTemplates3 } = schema_exports;
-    await db.delete(taskRuns4);
-    await db.delete(taskTemplates3);
-    await db.delete(tasks3);
-    return c.json({ success: true });
+    const result = DatabaseMaintenanceService.clear({ allowCurrentGateway: true });
+    return c.json({ success: true, ...result });
   } catch (err) {
-    return c.json({ success: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    const status = err instanceof DatabaseMaintenanceConflictError ? 409 : 500;
+    return c.json({ success: false, error: err instanceof Error ? err.message : String(err) }, status);
   }
 });
 var dashboardApp = app;