ework-daemon 0.4.38 → 0.4.40

package/package.json

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

package/src/opencode.ts

@@ -283,6 +283,7 @@ export interface EngineOptions {
   daemonId: number;
   takeover?: TakeoverStrategy;
   backend?: RuntimeBackend;
+  gateChecker?: (issue: Issue) => Promise<{ allowed: boolean; reason: string }>;
 }
 
 function createDefaultBackend(cfg: Config): RuntimeBackend {
@@ -299,6 +300,7 @@ export class Engine {
   private readonly daemonId: number;
   private readonly takeover: TakeoverStrategy;
   private readonly backend: RuntimeBackend;
+  private gateChecker: (issue: Issue) => Promise<{ allowed: boolean; reason: string }>;
   private heartbeatTimer?: ReturnType<typeof setInterval>;
   private maxConcurrent: number;
   private maxConcurrentExplicit: boolean;
@@ -350,6 +352,7 @@ export class Engine {
     this.daemonId = opts.daemonId;
     this.takeover = opts.takeover ?? new RecloneStrategy(cfg);
     this.backend = opts.backend ?? createDefaultBackend(cfg);
+    this.gateChecker = opts.gateChecker ?? ((issue: Issue) => this.webGateAllows(issue));
     this.maxConcurrent = cfg.work.maxConcurrent;
     this.maxConcurrentExplicit = cfg.work.maxConcurrentExplicit;
     this.startGlobalObserver();
@@ -388,6 +391,25 @@ export class Engine {
     } catch { /* non-critical */ }
   }
 
+  private async webGateAllows(issue: Issue): Promise<{ allowed: boolean; reason: string }> {
+    const parts = issue.trackerScopeKey.split("/");
+    const owner = parts[0] ?? "";
+    const repo = parts.slice(1).join("/");
+    if (!owner || !repo) return { allowed: true, reason: "unparseable scope" };
+    const url = `${this.cfg.gitea.url}/api/v1/dispatch-state?owner=${encodeURIComponent(owner)}&repo=${encodeURIComponent(repo)}&number=${encodeURIComponent(issue.trackerIssueId)}`;
+    try {
+      const resp = await fetch(url, { signal: AbortSignal.timeout(5000), headers: { Authorization: `token ${this.cfg.gitea.token}` } });
+      if (!resp.ok) return { allowed: false, reason: `web returned ${resp.status}` };
+      const data = await resp.json() as { dispatchOff?: boolean; aiStatus?: string };
+      if (data.dispatchOff) return { allowed: false, reason: "dispatch off" };
+      if (data.aiStatus === "halted" || data.aiStatus === "dispatch_off") return { allowed: false, reason: `ai_status=${data.aiStatus}` };
+      return { allowed: true, reason: "ok" };
+    } catch (err) {
+      log.warn(`engine: web gate query failed for ${issue.trackerScopeKey}#${issue.trackerIssueId}: ${(err as Error).message} — fail-closed (skipping)`);
+      return { allowed: false, reason: `web unreachable: ${(err as Error).message}` };
+    }
+  }
+
   setMaxConcurrent(n: number): void {
     if (!Number.isFinite(n) || n < 1) return;
     this.maxConcurrent = Math.floor(n);
@@ -1100,6 +1122,17 @@ export class Engine {
   // ─── Process Manager ───
 
   private async execProcess(k: string, session: OpSession, issue: Issue, msg: Message) {
+    const gate = await this.gateChecker(issue);
+    if (!gate.allowed) {
+      log.info(`engine: execProcess blocked by web gate (${gate.reason}) for ${k}`);
+      await this.store.updateMessageStatus(msg.id, "failed", `gate: ${gate.reason}`);
+      this.running.delete(k);
+      this.currentMessage.delete(k);
+      this.currentModel.delete(k);
+      void this.dequeueAfterGate(k, session, issue);
+      return;
+    }
+
     const gen = (this.generation.get(k) ?? 0) + 1;
     this.generation.set(k, gen);
 
@@ -1373,6 +1406,12 @@ export class Engine {
     void this.drainGlobalPending();
   }
 
+  private async dequeueAfterGate(k: string, session: OpSession, issue: Issue): Promise<void> {
+    const next = await this.store.getNextPendingMessage(session.id);
+    if (!next) return;
+    await this.dequeueOrIdle(k, session, issue, next);
+  }
+
   private async drainGlobalPending(): Promise<void> {
     const slotsAvailable = this.maxConcurrent - this.running.size;
     if (slotsAvailable <= 0) return;
@@ -1555,6 +1594,11 @@ export class Engine {
 
     for (const issue of ownedIssues) {
       try {
+    const gate = await this.gateChecker(issue);
+        if (!gate.allowed) {
+          log.info(`engine: observer — web gate blocked ${issue.trackerScopeKey}#${issue.trackerIssueId} (${gate.reason})`);
+          continue;
+        }
         await this.observeIssue(issue);
       } catch (err) {
         log.error(`engine: observer error for ${issue.trackerScopeKey}#${issue.trackerIssueId}:`, (err as Error).message);
@@ -1787,6 +1831,13 @@ export class Engine {
       const issue = await this.store.getIssue(session.issueId);
       if (!issue || issue.state === "closed") continue;
 
+      const gate = await this.webGateAllows(issue);
+      if (!gate.allowed) {
+        log.info(`engine: recover — web gate blocked ${issue.trackerScopeKey}#${issue.trackerIssueId} (${gate.reason}), marking pending messages as skipped`);
+        for (const m of msgs) await this.store.updateMessageStatus(m.id, "failed", `web gate: ${gate.reason}`);
+        continue;
+      }
+
       const k = this.sessionKey(session, issue);
       if (this.running.has(k)) continue;