ework-daemon 0.4.35 → 0.4.37

package/package.json

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

package/src/config.ts

@@ -26,6 +26,9 @@ export const configSchema = z.object({
     host: z.string().default("0.0.0.0"),
     endpoint: z.string().default(""),
     nonWakingAuthors: z.array(z.string()).default([]),
+    wakeKinds: z.array(z.string()).default(["human"]),
+    wakeLogins: z.array(z.string()).default([]),
+    noWakeLogins: z.array(z.string()).default([]),
   }),
   opencode: z.object({
     binary: z.string().default("opencode"),
@@ -144,6 +147,9 @@ export function loadConfig(): Config {
         host: process.env.DAEMON_HOST ?? TEST_DEFAULTS.daemon.host,
         endpoint: process.env.DAEMON_ENDPOINT ?? "",
         nonWakingAuthors: (process.env.WORK_NON_WAKING_AUTHORS ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+        wakeKinds: (process.env.WORK_WAKE_KINDS ?? "human").split(",").map((s) => s.trim()).filter(Boolean),
+        wakeLogins: (process.env.WORK_WAKE_LOGINS ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+        noWakeLogins: (process.env.WORK_NO_WAKE_LOGINS ?? "").split(",").map((s) => s.trim()).filter(Boolean),
       },
       opencode: {
         binary: process.env.OPENCODE_BINARY ?? TEST_DEFAULTS.opencode.binary,

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
@@ -601,10 +669,21 @@ export class Engine {
 
     if (event.type === "comment_created" && event.comment?.author) {
       const author = event.comment.author;
-      if (this.cfg.daemon.nonWakingAuthors.includes(author)) {
+      const authorKind = event.comment.author_kind ?? "human";
+      const d = this.cfg.daemon;
+      const noWake = [...d.nonWakingAuthors, ...d.noWakeLogins];
+      if (noWake.includes(author)) {
         log.info(`engine: non-waking author ${author} — skipping comment_created for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
         return;
       }
+      if (d.wakeLogins.length > 0 && !d.wakeLogins.includes(author)) {
+        log.info(`engine: author ${author} not in wakeLogins — skipping comment_created for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
+        return;
+      }
+      if (!d.wakeKinds.includes(authorKind)) {
+        log.info(`engine: author kind ${authorKind} not in wakeKinds [${d.wakeKinds.join(",")}] — skipping comment_created for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
+        return;
+      }
     }
 
     const issueMapKey = `${ref.trackerType}:${scopeKey}#${ref.issueId}`;

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;

package/src/trackers/gitea-tracker.ts

@@ -175,6 +175,7 @@ export class GiteaTracker implements IssueTracker {
           id: String(comment.id),
           body: comment.body as string,
           author: commentUser?.login ?? "",
+          author_kind: (comment as Record<string, unknown>).author_kind as string | undefined,
         },
         model,
         cloneUrl,

package/src/trackers/types.ts

@@ -29,6 +29,7 @@ export interface TrackerEvent {
     id: string;
     body: string;
     author: string;
+    author_kind?: string;
   };
   // Resolved "provider/model" string from ework-web (project override or
   // global default). Empty/undefined = no override; engine omits --model