opencode-supertask 0.1.21 → 0.1.23

package/dist/gateway/index.js

@@ -6543,6 +6543,23 @@ var init_task_service = __esm({
         ).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),
@@ -6878,6 +6895,80 @@ var init_health = __esm({
   }
 });
 
+// src/core/process-control.ts
+import { spawnSync } from "child_process";
+import { basename } from "path";
+function isSafePid(pid) {
+  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
+}
+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";
+  }
+}
+function inspectUnixProcess(pid) {
+  const result = spawnSync("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  const match2 = result.stdout.trim().match(/^(\d+)\s+(.+)$/s);
+  if (!match2) return null;
+  return { processGroupId: Number(match2[1]), command: match2[2] };
+}
+function commandMatches(command, expectedExecutable) {
+  const expectedName = basename(expectedExecutable).trim().toLowerCase();
+  if (!expectedName) return false;
+  return command.toLowerCase().includes(expectedName);
+}
+function signalSpawnedProcessTree(pid, signal) {
+  if (!isSafePid(pid)) return false;
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return true;
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function signalRecordedProcessTree(pid, signal, expectedExecutable) {
+  if (!isSafePid(pid)) return false;
+  if (process.platform === "win32") {
+    const list = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (list.status !== 0 || !commandMatches(list.stdout, expectedExecutable)) return false;
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    return spawnSync("taskkill", args, { stdio: "ignore" }).status === 0;
+  }
+  const info = inspectUnixProcess(pid);
+  if (!info || !commandMatches(info.command, expectedExecutable)) return false;
+  try {
+    if (info.processGroupId === pid) process.kill(-pid, signal);
+    else process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_process_control = __esm({
+  "src/core/process-control.ts"() {
+    "use strict";
+  }
+});
+
 // node_modules/cron-parser/dist/fields/types.js
 var require_types = __commonJS({
   "node_modules/cron-parser/dist/fields/types.js"(exports) {
@@ -14091,26 +14182,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);
@@ -18502,14 +18593,346 @@ var init_html2 = __esm({
   }
 });
 
+// src/core/services/database-maintenance.service.ts
+import { Database as Database3 } from "bun:sqlite";
+import { randomUUID } from "crypto";
+import {
+  chmodSync,
+  constants,
+  copyFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { basename as basename2, dirname as dirname2, resolve } from "path";
+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 REQUIRED_TABLES, DatabaseMaintenanceConflictError, DatabaseMaintenanceService;
+var init_database_maintenance_service = __esm({
+  "src/core/services/database-maintenance.service.ts"() {
+    "use strict";
+    init_db2();
+    init_process_control();
+    REQUIRED_TABLES = ["gateway_lock", "tasks", "task_runs", "task_templates"];
+    DatabaseMaintenanceConflictError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DatabaseMaintenanceConflictError";
+      }
+    };
+    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 (!existsSync3(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 && existsSync3(rollbackPath)) {
+            safeUnlink(livePath);
+            renameSync(rollbackPath, livePath);
+            try {
+              const original = getSqlite();
+              original.query("DELETE FROM gateway_lock WHERE pid = ?").run(process.pid);
+            } catch {
+            }
+          } else if (existsSync3(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:" || !existsSync3(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 (existsSync3(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" : basename2(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/web/index.tsx
 var web_exports = {};
 __export(web_exports, {
   dashboardApp: () => dashboardApp,
   default: () => web_default
 });
-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";
 function parsePositiveInteger(value) {
   if (!/^\d+$/.test(value)) return null;
   const parsed = Number(value);
@@ -18559,7 +18982,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 {
@@ -18568,11 +18991,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);
 }
 function renderLayout(title, activeTab, body) {
   return `<!DOCTYPE html><html><head><meta charset="UTF-8"><title>${title} - SuperTask</title>${SHARED_STYLES}
@@ -18589,12 +19012,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);}
 }
@@ -18655,6 +19078,7 @@ var init_web = __esm({
     init_task_service();
     init_task_run_service();
     init_task_template_service();
+    init_database_maintenance_service();
     init_drizzle_orm();
     init_db2();
     init_config();
@@ -18963,7 +19387,7 @@ var init_web = __esm({
       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) {
@@ -19037,7 +19461,7 @@ var init_web = __esm({
 
       <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));
@@ -19142,14 +19566,16 @@ var init_web = __esm({
       }
     });
     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: taskTemplates4 } = schema_exports;
-        await db.delete(taskRuns4);
-        await db.delete(taskTemplates4);
-        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);
       }
     });
     dashboardApp = app;
@@ -19168,69 +19594,8 @@ init_config();
 init_task_service();
 init_task_run_service();
 init_health();
+init_process_control();
 import { spawn } from "child_process";
-
-// src/core/process-control.ts
-import { spawnSync } from "child_process";
-import { basename } from "path";
-function isSafePid(pid) {
-  return Number.isInteger(pid) && pid > 1 && pid !== process.pid;
-}
-function inspectUnixProcess(pid) {
-  const result = spawnSync("ps", ["-o", "pgid=", "-o", "command=", "-p", String(pid)], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  if (result.status !== 0) return null;
-  const match2 = result.stdout.trim().match(/^(\d+)\s+(.+)$/s);
-  if (!match2) return null;
-  return { processGroupId: Number(match2[1]), command: match2[2] };
-}
-function commandMatches(command, expectedExecutable) {
-  const expectedName = basename(expectedExecutable).trim().toLowerCase();
-  if (!expectedName) return false;
-  return command.toLowerCase().includes(expectedName);
-}
-function signalSpawnedProcessTree(pid, signal) {
-  if (!isSafePid(pid)) return false;
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-pid, signal);
-      return true;
-    } catch {
-    }
-  }
-  try {
-    process.kill(pid, signal);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function signalRecordedProcessTree(pid, signal, expectedExecutable) {
-  if (!isSafePid(pid)) return false;
-  if (process.platform === "win32") {
-    const list = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    if (list.status !== 0 || !commandMatches(list.stdout, expectedExecutable)) return false;
-    const args = ["/PID", String(pid), "/T"];
-    if (signal === "SIGKILL") args.push("/F");
-    return spawnSync("taskkill", args, { stdio: "ignore" }).status === 0;
-  }
-  const info = inspectUnixProcess(pid);
-  if (!info || !commandMatches(info.command, expectedExecutable)) return false;
-  try {
-    if (info.processGroupId === pid) process.kill(-pid, signal);
-    else process.kill(pid, signal);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/worker/index.ts
 var DEFAULT_MAX_OUTPUT_CHARS = 64 * 1024;
 var FORBIDDEN_AGENT = "supertask-runner";
 var WorkerEngine = class {
@@ -19493,14 +19858,14 @@ ${output}` : ""}`;
     if (entry.child.exitCode !== null || entry.child.signalCode !== null) {
       return Promise.resolve();
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         this.signalEntry(entry, "SIGKILL");
-        resolve();
+        resolve2();
       }, 5e3);
       entry.child.once("close", () => {
         clearTimeout(timeout);
-        resolve();
+        resolve2();
       });
       this.signalEntry(entry, "SIGTERM");
     });
@@ -19532,6 +19897,7 @@ ${output}` : ""}`;
 init_task_run_service();
 init_task_service();
 init_backoff();
+init_process_control();
 async function checkHeartbeats(heartbeatTimeoutMs) {
   const staleRuns = await TaskRunService.getStaleRuns(heartbeatTimeoutMs);
   if (staleRuns.length === 0) return;
@@ -19833,6 +20199,7 @@ init_db2();
 init_task_service();
 init_task_run_service();
 init_health();
+init_process_control();
 var STALE_THRESHOLD_MS = 3e4;
 function acquireLock() {
   const now = Date.now();
@@ -19841,7 +20208,8 @@ function acquireLock() {
     sqlite.exec("BEGIN IMMEDIATE");
     const existing = sqlite.prepare("SELECT id, pid, heartbeat_at FROM gateway_lock WHERE id = 1").get();
     if (existing) {
-      if (now - existing.heartbeat_at < STALE_THRESHOLD_MS) {
+      const lockHolderAlive = existing.pid !== pid && isProcessAlive(existing.pid);
+      if (now - existing.heartbeat_at < STALE_THRESHOLD_MS && lockHolderAlive) {
         sqlite.exec("ROLLBACK");
         console.error(JSON.stringify({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -19911,6 +20279,15 @@ async function main() {
   const worker = new WorkerEngine(cfg);
   const watchdog = new Watchdog(cfg);
   const scheduler = new Scheduler(cfg);
+  const recoveredOrphans = await TaskService.resetOrphanRunningToPending();
+  if (recoveredOrphans > 0) {
+    console.log(JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "warn",
+      msg: "reset orphan running tasks to pending",
+      count: recoveredOrphans
+    }));
+  }
   initializeGatewayHealth({
     workerPollIntervalMs: cfg.worker.pollIntervalMs,
     schedulerEnabled: cfg.scheduler.enabled,
@@ -19981,6 +20358,8 @@ if (import.meta.main) {
   main();
 }
 export {
-  main
+  acquireLock,
+  main,
+  releaseLock
 };
 //# sourceMappingURL=index.js.map