ework-daemon 0.4.21 → 0.4.23

package/package.json

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

package/src/config.ts

@@ -64,6 +64,7 @@ export const configSchema = z.object({
     maxLines: z.coerce.number().int().positive().default(2000),
     maxBytes: z.coerce.number().int().positive().default(524288),
   }).default({ roots: [], maxLines: 2000, maxBytes: 524288 }),
+  childEnvDeny: z.array(z.string()).default([]),
 });
 
 export type Config = z.infer<typeof configSchema>;
@@ -145,6 +146,7 @@ export function loadConfig(): Config {
         thresholdMs: Number(process.env.DAEMON_STUCK_THRESHOLD_MS) || 30 * 60 * 1000,
         maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
       } : undefined,
+      childEnvDeny: (process.env.WORK_CHILD_ENV_DENY ?? "").split(",").map((s) => s.trim()).filter(Boolean),
     });
   }
 
@@ -188,5 +190,6 @@ export function loadConfig(): Config {
       maxLines: Number(process.env.WORK_FILE_MAX_LINES) || 2000,
       maxBytes: Number(process.env.WORK_FILE_MAX_BYTES) || 524288,
     },
+    childEnvDeny: (process.env.WORK_CHILD_ENV_DENY ?? "").split(",").map((s) => s.trim()).filter(Boolean),
   });
 }

package/src/gitea.ts

@@ -63,6 +63,23 @@ export class GiteaClient {
     }, true);
   }
 
+  async updateIssueStatus(
+    owner: string,
+    repo: string,
+    issueNumber: number,
+    status: string,
+    detail?: string
+  ): Promise<void> {
+    try {
+      await this.request("POST", `/repos/${owner}/${repo}/issues/${issueNumber}/status`, {
+        status,
+        detail,
+      }, true);
+    } catch {
+      // Status callback is best-effort — don't block processing on API failure.
+    }
+  }
+
   async editComment(
     owner: string,
     repo: string,

package/src/opencode.ts

@@ -308,6 +308,7 @@ export class Engine {
   private processExitNudgeRounds = new Map<string, number>();
   private stuckNudgeRounds = new Map<string, number>();
   private currentPrompt = new Map<string, string>();
+  private paused = false;
 
   // Generation counter per session key — incremented on every execProcess call.
   // finishRun captures the generation at start and checks it after each await.
@@ -372,6 +373,22 @@ export class Engine {
     return this.daemonId;
   }
 
+  async pause(): Promise<void> {
+    this.paused = true;
+    await this.store.markDaemonStatus(this.daemonId, "drained");
+    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");
+    log.info(`engine: daemon ${this.daemonId} resumed (active)`);
+  }
+
+  isPaused(): boolean {
+    return this.paused;
+  }
+
   /**
    * 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
@@ -539,6 +556,11 @@ export class Engine {
     const tracker = this.getTracker(ref.trackerType);
     const scopeKey = tracker.formatScopeKey(ref.scope);
 
+    if (this.paused && event.type === "issue_opened") {
+      log.info(`engine: paused — skipping issue_opened for ${ref.trackerType}:${scopeKey}#${ref.issueId}`);
+      return;
+    }
+
     const issueMapKey = `${ref.trackerType}:${scopeKey}#${ref.issueId}`;
     if (groupConfig) {
       this.groupConfigs.set(issueMapKey, groupConfig);
@@ -557,6 +579,11 @@ export class Engine {
         return this.handleCommented(ref, scopeKey, issueData, event.comment!, tracker, event.model);
       case "issue_closed":
         return this.handleClosed(ref, scopeKey, tracker);
+      case "status_changed": {
+        const to = event.status?.to;
+        if (to === "halted") return this.handleHalted(ref, scopeKey, tracker);
+        return;
+      }
     }
   }
 
@@ -607,6 +634,7 @@ export class Engine {
     log.info(`engine: session "${session.name}" created for ${k}, workdir=${workdir}`);
 
     await tracker.createComment(ref, `[system] 🔄 **${session.name}** picked up this issue.\n> session: ${this.sessionRef(session)} | workdir: ${this.workdirLink(workdir)}`);
+    void tracker.updateStatus(ref, "processing");
 
     const instructions = tracker.getTrackerInstructions(ref);
     const prompt = this.buildInitialPrompt(
@@ -791,6 +819,36 @@ export class Engine {
     this.senders.delete(gcKey);
 
     log.info(`engine: issue closed, ${sessions.length} sessions paused for ${scopeKey}#${ref.issueId}`);
+    void tracker.updateStatus(ref, "completed");
+  }
+
+  private async handleHalted(
+    ref: TrackerRef,
+    scopeKey: string,
+    tracker: IssueTracker
+  ) {
+    const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
+    if (!issue) return;
+    this.stopObserver(issue.id);
+    const sessions = await this.store.getSessionsForIssue(issue.id);
+    for (const session of sessions) {
+      const k = this.sessionKey(session, issue);
+      const proc = this.processes.get(k);
+      if (proc) {
+        this.stopping.add(k);
+        try { this.killProcessTree(proc.pid, "SIGTERM"); } catch { /* already dead */ }
+      }
+      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 user");
+        }
+      }
+      await this.store.updateSession(session.id, { state: "idle", opencodePid: undefined });
+    }
+    log.info(`engine: issue halted, ${sessions.length} sessions killed for ${scopeKey}#${ref.issueId}`);
+    try { await tracker.createComment(ref, "[system] ⏸️ AI processing halted by user."); } catch { /* tracker unavailable */ }
   }
 
   private clearRuntimeState(k: string) {
@@ -941,14 +999,13 @@ export class Engine {
     // (the operator's explicit config) instead of arbitrary env pollution.
     // Provider keys / Gitea vars are preserved (opencode + its plugin need
     // them); only the explicit model-override var is neutralized.
-    const childEnv = { ...process.env };
+    const childEnv = { ...process.env, ...this.hookEnvFor(issue, session, workdir) };
     if (!model) delete childEnv.OPENCODE_MODEL;
-    // Strip parent-session env vars so the child opencode reads its own
-    // opencode.json instead of inheriting a parent session's model/provider.
     delete childEnv.OPENCODE;
     delete childEnv.OPENCODE_PID;
     delete childEnv.OPENCODE_RUN_ID;
     delete childEnv.OPENCODE_PROCESS_ROLE;
+    for (const k of this.cfg.childEnvDeny) delete childEnv[k];
 
     try {
       const proc = spawn({

package/src/server.ts

@@ -205,6 +205,15 @@ export function createServer(
       }
     }
 
+    if (pathname === "/api/admin/pause" && req.method === "POST") {
+      await engine.pause();
+      return json({ ok: true, paused: true });
+    }
+    if (pathname === "/api/admin/resume" && req.method === "POST") {
+      await engine.resume();
+      return json({ ok: true, paused: false });
+    }
+
     return json({ error: "not found" }, 404);
   }
 

package/src/trackers/gitea-tracker.ts

@@ -65,6 +65,12 @@ export class GiteaTracker implements IssueTracker {
     );
   }
 
+  async updateStatus(ref: TrackerRef, status: string, detail?: string) {
+    await this.client.updateIssueStatus(
+      this.owner(ref), this.repo(ref), Number(ref.issueId), status, detail
+    );
+  }
+
   async setReaction(ref: TrackerRef, commentId: string, content: string, remove = false) {
     if (remove) {
       await this.client.removeCommentReaction(
@@ -189,6 +195,26 @@ export class GiteaTracker implements IssueTracker {
       };
     }
 
+    if (action === "status_changed") {
+      const status = payload.status as { from?: string; to?: string; detail?: string } | undefined;
+      return {
+        type: "status_changed" as const,
+        ref,
+        issue: {
+          title: issue.title as string,
+          body: (issue.body as string) ?? "",
+          state: (issue.state as string) ?? "open",
+          author: issueUser?.login ?? "",
+        },
+        status: {
+          from: status?.from ?? "",
+          to: status?.to ?? "",
+          detail: status?.detail,
+        },
+        sender,
+      };
+    }
+
     return null;
   }
 

package/src/trackers/types.ts

@@ -13,7 +13,7 @@ export interface TrackerRef {
 }
 
 /** Parsed, tracker-agnostic webhook event */
-export type TrackerEventType = "issue_opened" | "comment_created" | "issue_closed";
+export type TrackerEventType = "issue_opened" | "comment_created" | "issue_closed" | "status_changed";
 
 export interface TrackerEvent {
   type: TrackerEventType;
@@ -39,6 +39,7 @@ export interface TrackerEvent {
   // Webhook sender (who triggered the event). Forwarded to the daemon's
   // task context so the AI knows who it's responding to.
   sender?: string;
+  status?: { from: string; to: string; detail?: string };
 }
 
 /** Tracker-agnostic comment */
@@ -130,6 +131,7 @@ export interface IssueTracker {
   deleteComment(ref: TrackerRef, commentId: string): Promise<void>;
   listComments(ref: TrackerRef): Promise<TrackerComment[]>;
   closeIssue(ref: TrackerRef): Promise<void>;
+  updateStatus(ref: TrackerRef, status: string, detail?: string): Promise<void>;
 
   setReaction(ref: TrackerRef, commentId: string, content: string, remove?: boolean): Promise<void>;