ework-daemon 0.4.34 → 0.4.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.4.34",
+  "version": "0.4.36",
   "description": "Issue-driven AI development daemon. Spawns opencode subprocesses to resolve Gitea issues.",
   "module": "src/index.ts",
   "type": "module",

package/src/index.ts

@@ -73,6 +73,7 @@ async function boot() {
   if (claimed > 0) log.info(`  first-boot migration: claimed ${claimed} previously-ownerless issue(s)`);
 
   const engine = new Engine(config, store, trackers, { daemonId });
+  engine.restorePausedState();
   engine.startHeartbeat(config.work.heartbeatMs);
   const server = createServer(config, store, engine, trackers);
 

package/src/opencode.ts

@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import { mkdirSync, writeFileSync, readdirSync, existsSync, readFileSync } from "fs";
+import { mkdirSync, writeFileSync, unlinkSync, readdirSync, existsSync, readFileSync } from "fs";
 import { join, resolve, isAbsolute } from "path";
 import { homedir } from "os";
 import { log } from "./logger";
@@ -413,12 +413,14 @@ export class Engine {
   async pause(): Promise<void> {
     this.paused = true;
     await this.store.markDaemonStatus(this.daemonId, "drained");
+    this.persistPaused(true);
     log.info(`engine: daemon ${this.daemonId} paused (drained) — new issues rejected, existing sessions continue`);
   }
 
   async resume(): Promise<void> {
     this.paused = false;
     await this.store.markDaemonStatus(this.daemonId, "active");
+    this.persistPaused(false);
     log.info(`engine: daemon ${this.daemonId} resumed (active)`);
   }
 
@@ -426,6 +428,72 @@ export class Engine {
     return this.paused;
   }
 
+  getRunningCount(): number {
+    return this.running.size;
+  }
+
+  /**
+   * Force-terminate ALL running sessions on this daemon. Returns kill count.
+   * Unlike pause() (which only rejects new work), this actively kills
+   * in-progress opencode/Pi processes.
+   */
+  async haltAll(): Promise<number> {
+    let killed = 0;
+    const issues = await this.store.listOwnedIssues(this.daemonId);
+    for (const issue of issues) {
+      const sessions = await this.store.getSessionsForIssue(issue.id);
+      for (const session of sessions) {
+        if (session.state !== "running") continue;
+        const k = this.sessionKey(session, issue);
+        const wasKilled = await this.killSessionProcess(session, k);
+        if (wasKilled) killed++;
+        this.clearRuntimeState(k);
+        const msgs = await this.store.getMessagesForSession(session.id);
+        for (const msg of msgs) {
+          if (msg.status === "pending" || msg.status === "running") {
+            await this.store.updateMessageStatus(msg.id, "interrupted", "halted by admin");
+          }
+        }
+        await this.store.updateSession(session.id, { state: "idle", opencodePid: undefined });
+        const tracker = this.trackers.get(issue.trackerType);
+        if (tracker) {
+          try {
+            await tracker.createComment(
+              { trackerType: issue.trackerType, scope: issue.trackerScope, issueId: issue.trackerIssueId },
+              `[system] ⏹️ Session **${session.name}** force-stopped by admin (halt-all).`
+            );
+          } catch { /* tracker unavailable */ }
+        }
+      }
+    }
+    this.paused = true;
+    await this.store.markDaemonStatus(this.daemonId, "drained");
+    this.persistPaused(true);
+    log.info(`engine: haltAll complete — ${killed} sessions killed, daemon ${this.daemonId} now paused`);
+    return killed;
+  }
+
+  private pausedFilePath(): string {
+    return join(this.cfg.opencode.baseWorkdir, "..", ".ework-paused.flag");
+  }
+
+  private persistPaused(paused: boolean): void {
+    try {
+      const p = this.pausedFilePath();
+      if (paused) writeFileSync(p, String(Date.now()));
+      else if (existsSync(p)) unlinkSync(p);
+    } catch { /* best-effort persistence */ }
+  }
+
+  restorePausedState(): void {
+    try {
+      if (existsSync(this.pausedFilePath())) {
+        this.paused = true;
+        log.info(`engine: daemon ${this.daemonId} restored paused state from flag file`);
+      }
+    } catch { /* best-effort */ }
+  }
+
   /**
    * Ensure this engine owns the issue before doing work on it. Returns true
    * if we own it (either already, or just claimed). Returns false if another
@@ -594,8 +662,8 @@ export class Engine {
       return;
     }
 
-    if (issueData.ai_status === "halted" && (event.type === "issue_opened" || event.type === "comment_created")) {
-      log.info(`engine: issue halted — skipping ${event.type} for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
+    if ((issueData.ai_status === "halted" || issueData.ai_status === "dispatch_off") && (event.type === "issue_opened" || event.type === "comment_created")) {
+      log.info(`engine: issue ${issueData.ai_status} — skipping ${event.type} for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
       return;
     }
 

package/src/server.ts

@@ -82,6 +82,8 @@ export function createServer(
         pending: status.pendingCount,
         processes: status.processCount,
         maxConcurrent: engine.getMaxConcurrent(),
+        paused: engine.isPaused(),
+        runningCount: engine.getRunningCount(),
         observedIssues: status.observedIssues,
         issues: (await store.listAllIssues()).length,
         sessions: (await store.listAllSessions()).length,
@@ -214,6 +216,10 @@ export function createServer(
       await engine.resume();
       return json({ ok: true, paused: false });
     }
+    if (pathname === "/api/admin/halt-all" && req.method === "POST") {
+      const killed = await engine.haltAll();
+      return json({ ok: true, killed, paused: true });
+    }
     if (pathname === "/api/admin/max-concurrent" && req.method === "POST") {
       const body = await req.json().catch(() => ({} as unknown));
       const value = (body as { value?: unknown })?.value;