ework-daemon 0.4.63 → 0.4.65

package/package.json

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

package/src/attachments.ts

@@ -0,0 +1,102 @@
+import { mkdir, writeFile } from "node:fs/promises";
+
+/**
+ * ework-web attachment links: `[name](/attachments/<uuid>)` in issue bodies
+ * and comments. The web requires auth on that route, but the daemon's Gitea
+ * PAT is accepted (same auth surface as cookies), so the daemon downloads
+ * attachments for the agent instead of teaching it to curl with tokens.
+ */
+export const ATTACHMENT_LINK_RE = /\/attachments\/([0-9a-fA-F-]{36})/g;
+
+export interface DownloadedAttachment {
+  uuid: string;
+  filename: string;
+  size: number;
+  /** Reason the referenced attachment was not downloaded, if any. */
+  skipped?: string;
+}
+
+export const MAX_ATTACHMENT_BYTES = 64 * 1024 * 1024;
+
+function sanitizeFilename(raw: string, fallback: string): string {
+  const cleaned = raw
+    .replace(/[\u0000-\u001f\u007f]/g, "")
+    .replace(/[/\\]/g, "_")
+    .replace(/^\.+/, "")
+    .trim();
+  return cleaned || fallback;
+}
+
+/**
+ * Download every /attachments/<uuid> referenced in `content` into
+ * `<workdir>/attachments/` using the daemon's Gitea PAT. Best-effort:
+ * failures are reported per-attachment via `skipped`, never thrown.
+ */
+export async function downloadIssueAttachments(
+  content: string,
+  baseUrl: string,
+  token: string,
+  workdir: string,
+): Promise<DownloadedAttachment[]> {
+  const uuids = new Set<string>();
+  for (const m of content.matchAll(ATTACHMENT_LINK_RE)) {
+    if (m[1]) uuids.add(m[1]);
+  }
+  if (uuids.size === 0) return [];
+  const base = baseUrl.replace(/\/+$/, "");
+  const out: DownloadedAttachment[] = [];
+  for (const uuid of uuids) {
+    try {
+      const res = await fetch(`${base}/attachments/${uuid}`, {
+        headers: { authorization: `token ${token}` },
+        signal: AbortSignal.timeout(120_000),
+        // Auth failures surface as 302 -> login; treat redirects as failures
+        // instead of following them to the login page.
+        redirect: "manual",
+      });
+      if (res.status >= 300 && res.status < 400) {
+        out.push({ uuid, filename: "", size: 0, skipped: `HTTP ${res.status} (auth)` });
+        continue;
+      }
+      if (!res.ok) {
+        out.push({ uuid, filename: "", size: 0, skipped: `HTTP ${res.status}` });
+        continue;
+      }
+      const lenHeader = Number(res.headers.get("content-length") ?? "0");
+      if (lenHeader > MAX_ATTACHMENT_BYTES) {
+        out.push({ uuid, filename: "", size: lenHeader, skipped: "too large" });
+        continue;
+      }
+      const cd = res.headers.get("content-disposition") ?? "";
+      const nameMatch = cd.match(/filename="([^"]*)"/);
+      const filename = sanitizeFilename(nameMatch?.[1] ?? "", `${uuid}.bin`);
+      const buf = Buffer.from(await res.arrayBuffer());
+      if (buf.length > MAX_ATTACHMENT_BYTES) {
+        out.push({ uuid, filename, size: buf.length, skipped: "too large" });
+        continue;
+      }
+      const dir = `${workdir}/attachments`;
+      await mkdir(dir, { recursive: true });
+      await writeFile(`${dir}/${filename}`, buf);
+      out.push({ uuid, filename, size: buf.length });
+    } catch (e) {
+      out.push({
+        uuid,
+        filename: "",
+        size: 0,
+        skipped: e instanceof Error ? e.message : "download error",
+      });
+    }
+  }
+  return out;
+}
+
+export function attachmentNote(atts: DownloadedAttachment[]): string {
+  if (atts.length === 0) return "";
+  const lines = atts.map((a) =>
+    a.skipped
+      ? `- ${a.filename || a.uuid}: 未能下载（${a.skipped}）`
+      : `- attachments/${a.filename}（${(a.size / 1024).toFixed(1)} KB）`,
+  );
+  return `\n\n[system] 本条消息引用的附件已由系统代为下载到工作目录的 attachments/ 目录：\n${lines.join("\n")}\n请直接用文件工具读取分析（日志类文件建议分段/grep 查看）。`;
+}

package/src/config.ts

@@ -74,6 +74,10 @@ export const configSchema = z.object({
     maxNudges: z.coerce.number().int().nonnegative(),
     maxRuntimeMs: z.coerce.number().positive(),
   }).optional(),
+  replyBurst: z.object({
+    max: z.coerce.number().int().positive(),
+    windowMs: z.coerce.number().positive(),
+  }).optional(),
   file: z.object({
     roots: z.array(z.string()).default([]),
     maxLines: z.coerce.number().int().positive().default(2000),
@@ -176,6 +180,10 @@ export function loadConfig(): Config {
         maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
         maxRuntimeMs: Number(process.env.DAEMON_STUCK_MAX_RUNTIME_MS) || 3 * 60 * 60 * 1000,
       } : undefined,
+      replyBurst: process.env.WORK_REPLY_BURST_MAX || process.env.WORK_REPLY_BURST_WINDOW_MS ? {
+        max: Number(process.env.WORK_REPLY_BURST_MAX) || 8,
+        windowMs: Number(process.env.WORK_REPLY_BURST_WINDOW_MS) || 5 * 60 * 1000,
+      } : undefined,
       childEnvDeny: (process.env.WORK_CHILD_ENV_DENY ?? "").split(",").map((s) => s.trim()).filter(Boolean),
     });
   }
@@ -224,6 +232,10 @@ export function loadConfig(): Config {
       maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
       maxRuntimeMs: Number(process.env.DAEMON_STUCK_MAX_RUNTIME_MS) || 3 * 60 * 60 * 1000,
     } : undefined,
+    replyBurst: process.env.WORK_REPLY_BURST_MAX || process.env.WORK_REPLY_BURST_WINDOW_MS ? {
+      max: Number(process.env.WORK_REPLY_BURST_MAX) || 8,
+      windowMs: Number(process.env.WORK_REPLY_BURST_WINDOW_MS) || 5 * 60 * 1000,
+    } : undefined,
     file: {
       roots: (process.env.WORK_FILE_ROOTS ?? "").split(":").filter(Boolean).length > 0
         ? (process.env.WORK_FILE_ROOTS ?? "").split(":").filter(Boolean)

package/src/opencode.ts

@@ -10,6 +10,7 @@ import { formatKey, parseKey } from "./trackers/types";
 import type { RuntimeBackend, RuntimeHandle } from "./runtime/types";
 import { OpencodeBackend } from "./runtime/opencode-backend";
 import { PiBackend } from "./runtime/pi-backend";
+import { downloadIssueAttachments, attachmentNote } from "./attachments";
 
 // ─── Types ───
 
@@ -300,6 +301,7 @@ export interface EngineOptions {
   takeover?: TakeoverStrategy;
   backend?: RuntimeBackend;
   gateChecker?: (issue: Issue) => Promise<{ allowed: boolean; reason: string }>;
+  replyBurst?: { max: number; windowMs: number };
 }
 
 function createDefaultBackend(cfg: Config): RuntimeBackend {
@@ -330,6 +332,19 @@ export function wakePolicySkips(
   return null;
 }
 
+// Reply-burst circuit breaker state: prune timestamps to the sliding window,
+// trip when the retained count reaches max. Pure for testability.
+export function replyBurstState(
+  stamps: number[],
+  now: number,
+  max: number,
+  windowMs: number,
+): { tripped: boolean; kept: number[] } {
+  const kept = stamps.filter((t) => now - t < windowMs);
+  kept.push(now);
+  return { tripped: kept.length >= max, kept };
+}
+
 // Per-issue npm prefix: `npm install -g <pkg>` inside a session lands in the issue's
 // workdir instead of the system global, so concurrent agents debugging different
 // issues cannot clobber each other's global installs (nor poison the shared daemon env).
@@ -397,6 +412,8 @@ export class Engine {
   private altBackend?: RuntimeBackend;
   private senders = new Map<string, string>();
   private envInitialized = new Set<string>();
+  private replyBurstCfg?: { max: number; windowMs: number };
+  private replyStamps = new Map<string, number[]>();
 
   private static MAX_INLINE_SIZE = 4000;
   private static MAX_NUDGE_ROUNDS = 1;
@@ -405,6 +422,8 @@ export class Engine {
   private static MAX_RUNTIME_MS = 3 * 60 * 60 * 1000;
   private static OBSERVER_INTERVAL_MS = 5 * 60 * 1000;
   private static STUCK_THRESHOLD_MS = 30 * 60 * 1000;
+  private static MAX_REPLY_BURST = 8;
+  private static REPLY_BURST_WINDOW_MS = 5 * 60 * 1000;
   private static MAX_PROCESS_EXIT_NUDGE_ROUNDS = 1;
 
   constructor(cfg: Config, store: Store, trackers: TrackerRegistry, opts: EngineOptions) {
@@ -415,6 +434,7 @@ export class Engine {
     this.takeover = opts.takeover ?? new RecloneStrategy(cfg);
     this.backend = opts.backend ?? createDefaultBackend(cfg);
     this.gateChecker = opts.gateChecker ?? ((issue: Issue) => this.webGateAllows(issue));
+    this.replyBurstCfg = opts.replyBurst ?? cfg.replyBurst;
     this.maxConcurrent = cfg.work.maxConcurrent;
     this.maxConcurrentExplicit = cfg.work.maxConcurrentExplicit;
     this.startGlobalObserver();
@@ -782,6 +802,13 @@ export class Engine {
       return;
     }
 
+    // Self-authored comment (our own reply landing back): never wake on it,
+    // but feed the reply-burst circuit breaker first.
+    if (event.type === "comment_created" && event.comment?.author === this.cfg.bot.username) {
+      await this.trackSelfReply(ref, scopeKey, tracker);
+      return;
+    }
+
     const wakeAuthor = event.type === "comment_created" ? event.comment?.author : event.type === "issue_opened" ? event.issue?.author : undefined;
     const wakeKind = event.type === "comment_created" ? event.comment?.authorKind ?? "human" : "human";
     if (wakeAuthor) {
@@ -821,6 +848,33 @@ export class Engine {
     }
   }
 
+  // Reply-burst circuit breaker: a looping session can re-perceive a standing
+  // instruction every agent turn and invoke the reply tool indefinitely. Our
+  // own replies come back as comment_created events, so count them per issue
+  // and kill the running sessions when they exceed max within the window.
+  private async trackSelfReply(ref: TrackerRef, scopeKey: string, tracker: IssueTracker) {
+    const key = `${ref.trackerType}:${scopeKey}#${ref.issueId}`;
+    const max = this.replyBurstCfg?.max ?? Engine.MAX_REPLY_BURST;
+    const windowMs = this.replyBurstCfg?.windowMs ?? Engine.REPLY_BURST_WINDOW_MS;
+    const { tripped, kept } = replyBurstState(this.replyStamps.get(key) ?? [], Date.now(), max, windowMs);
+    this.replyStamps.set(key, kept);
+    if (!tripped) return;
+    this.replyStamps.delete(key);
+    const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
+    if (!issue) return;
+    const sessions = await this.store.getSessionsForIssue(issue.id);
+    const killed: string[] = [];
+    for (const session of sessions) {
+      const k = this.sessionKey(session, issue);
+      if (!this.running.has(k)) continue;
+      const ok = await this.killSessionProcess(session, k);
+      if (ok) killed.push(session.name);
+    }
+    if (killed.length === 0) return; // burst authored elsewhere (another daemon) — nothing to kill here
+    log.warn(`engine: reply-burst breaker tripped for ${key} (${max} replies in ${Math.round(windowMs / 1000)}s) — killed ${killed.join(", ")}`);
+    await tracker.createComment(ref, `[system] ⚠️ Reply-burst circuit breaker: ${max} replies within ${Math.round(windowMs / 60000)} min — stopped ${killed.length > 1 ? `${killed.length} sessions` : `session **${killed[0]}**`}. Post a comment to wake it again.`).catch((err) => log.error(`engine: burst notice failed for ${key}:`, (err as Error).message));
+  }
+
   private groupConfigFor(issue: Issue): GroupConfig | undefined {
     return this.groupConfigs.get(`${issue.trackerType}:${issue.trackerScopeKey}#${issue.trackerIssueId}`);
   }
@@ -1024,6 +1078,7 @@ export class Engine {
     scopeKey: string,
     tracker: IssueTracker
   ) {
+    this.replyStamps.delete(`${ref.trackerType}:${scopeKey}#${ref.issueId}`);
     const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
     if (!issue) return;
     if (issue.state === "closed") return;
@@ -1073,6 +1128,7 @@ export class Engine {
     scopeKey: string,
     tracker: IssueTracker
   ) {
+    this.replyStamps.delete(`${ref.trackerType}:${scopeKey}#${ref.issueId}`);
     const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
     if (!issue) return;
     this.stopObserver(issue.id);
@@ -1278,13 +1334,33 @@ export class Engine {
 
     const childEnv = spawnEnvFor(process.env, this.hookEnvFor(issue, session, workdir), workdir);
 
+    let spawnPrompt = msg.content;
+    try {
+      const atts = await downloadIssueAttachments(
+        msg.content,
+        this.cfg.gitea.url,
+        this.cfg.gitea.token,
+        workdir,
+      );
+      if (atts.length > 0) {
+        log.info(
+          `engine: attachments for ${k}: ${atts
+            .map((a) => `${a.filename || a.uuid}${a.skipped ? ` (skip: ${a.skipped})` : ""}`)
+            .join(", ")}`,
+        );
+        spawnPrompt += attachmentNote(atts);
+      }
+    } catch {
+      // Best-effort: the agent still has the raw message without files.
+    }
+
     let exitCode: number | null = null;
 
     try {
       const handle = await backend.spawn(
         {
           workdir,
-          prompt: msg.content,
+          prompt: spawnPrompt,
           model: model || undefined,
           resumeSessionId: resumeSessionId || undefined,
           env: childEnv,