ework-daemon 0.1.1 → 0.1.3

package/package.json

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

package/src/opencode.ts

@@ -14,6 +14,51 @@ interface TrackerRegistry {
   get(type: string): IssueTracker | undefined;
 }
 
+/**
+ * Extract the target name of an @mention from comment text.
+ *
+ * Strips fenced + inline code first (terminal pastes with "user@host" / "git@repo"),
+ * then matches `@name`. Rejects two phantom-mention shapes that previously spawned
+ * stray agent sessions (ework-daemon#2):
+ *  - scoped package refs (`@types/node`, `@babel/core` — the trailing `/` means an
+ *    npm path, not a person);
+ *  - version-like `@<digits>` (`@123`).
+ *
+ * Exported so tests can pin the exact accept/reject behavior (regression coverage).
+ */
+export function detectMention(text: string): string | null {
+  const stripped = text
+    .replace(/```[\s\S]*?```/g, "")
+    .replace(/`[^`\n]*`/g, "");
+  const re = /(?:^|\s)@([\w\u4e00-\u9fff]+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(stripped)) !== null) {
+    const name = m[1];
+    if (!name) continue;
+    if (/^\d+$/.test(name)) continue;              // @<digits> → version ref, skip
+    if (stripped[re.lastIndex] === "/") continue;  // @scope/pkg → scoped package, skip
+    return name;
+  }
+  return null;
+}
+
+/**
+ * Pick the most recently active session from a list: the one whose process last
+ * started (`startedAt`), falling back to creation time when a session has never
+ * run yet. Returns `undefined` for an empty list.
+ *
+ * Used by the no-mention dispatch path to route a comment to a single session
+ * (the "last AI") instead of broadcasting to all of them.
+ */
+export function pickLastActive(sessions: OpSession[]): OpSession | undefined {
+  if (sessions.length === 0) return undefined;
+  return sessions.reduce((a, b) => {
+    const aT = a.startedAt ?? a.createdAt.getTime();
+    const bT = b.startedAt ?? b.createdAt.getTime();
+    return bT > aT ? b : a;
+  });
+}
+
 // ─── Engine ───
 
 export class Engine {
@@ -107,13 +152,21 @@ export class Engine {
   }
 
   private extractMentionName(text: string): string | null {
-    // Strip fenced code blocks (```...```) and inline code (`...`) before scanning for @mentions,
-    // otherwise pasted terminal output / code containing "user@host" or "git@repo" creates phantom sessions.
-    const stripped = text
-      .replace(/```[\s\S]*?```/g, "")
-      .replace(/`[^`\n]*`/g, "");
-    const match = stripped.match(/(?:^|\s)@([\w\u4e00-\u9fff]+)/);
-    return match?.[1] ?? null;
+    return detectMention(text);
+  }
+
+  /**
+   * Whitelist gate: default only the bot itself is a valid @mention target.
+   * Unknown names (misread from plain text — `@types/node`, etc.) don't spawn a
+   * new session; they fall back to broadcast. To run multiple named agents, set
+   * `DAEMON_ALLOWED_AGENTS=ework,tester,...`.
+   */
+  private isAllowedAgent(name: string): boolean {
+    const env = process.env.DAEMON_ALLOWED_AGENTS;
+    const allowed = env && env.trim()
+      ? env.split(",").map(s => s.trim()).filter(Boolean)
+      : [this.cfg.bot.username];
+    return allowed.includes(name);
   }
 
   private parseDirCommand(text: string): string | null {
@@ -261,7 +314,14 @@ export class Engine {
     }
 
     const dirPath = this.parseDirCommand(comment.body);
-    const mentionName = this.extractMentionName(comment.body);
+    const rawMention = this.extractMentionName(comment.body);
+    // Gate extracted @mentions through the agent whitelist. An unknown name
+    // (e.g. `@types` misread from `@types/node`) is treated as no mention and
+    // falls through to broadcast instead of spawning a phantom session (ework-daemon#2).
+    const mentionName = rawMention && this.isAllowedAgent(rawMention) ? rawMention : null;
+    if (rawMention && !mentionName) {
+      log.info(`engine: @${rawMention} is not an allowed agent — routing to last session instead of spawning`);
+    }
 
     if (mentionName) {
       // @mention → targeted delivery
@@ -304,27 +364,27 @@ export class Engine {
         this.enqueueOrRun(session, issue, prompt, comment.id, model);
       }
     } else {
-      // No @mention → broadcast to all sessions on this issue
+      // No valid @mention → forward to the most recently active session only.
+      // Broadcasting to all sessions makes multiple AIs race on the same request;
+      // routing to the last-active lets the user continue without re-@mentioning,
+      // while @mention switches to a different AI.
       const sessions = this.store.getSessionsForIssue(issue.id);
       if (sessions.length === 0) return;
 
-      for (const session of sessions) {
-        if (dirPath) {
-          this.store.updateSession(session.id, { workdir: dirPath });
-          session.workdir = dirPath;
-        }
-        const workdir = this.resolveWorkdir(session, issue);
-        const instructions = tracker.getTrackerInstructions(ref);
-        const prompt = this.buildForwardPrompt(
-          session.name, this.handleLargeContent(workdir, comment.body, `comment-${comment.id}.txt`),
-          comment.author, issueData.title, workdir, instructions
-        );
-        this.enqueueOrRun(session, issue, prompt, comment.id, model);
+      const session = pickLastActive(sessions);
+      if (!session) return;
+      if (dirPath) {
+        this.store.updateSession(session.id, { workdir: dirPath });
+        session.workdir = dirPath;
       }
-
-      // Immediate ack
-      const names = sessions.map(s => `**${s.name}** (\`${s.opencodeSessionId ?? s.id}\`, \`${this.resolveWorkdir(s, issue)}\`)`).join(", ");
-      await tracker.createComment(ref, `[system] ✓ Message broadcasted to: ${names}.`);
+      const workdir = this.resolveWorkdir(session, issue);
+      const instructions = tracker.getTrackerInstructions(ref);
+      const prompt = this.buildForwardPrompt(
+        session.name, this.handleLargeContent(workdir, comment.body, `comment-${comment.id}.txt`),
+        comment.author, issueData.title, workdir, instructions
+      );
+      await tracker.createComment(ref, `[system] ✓ Message forwarded to **${session.name}**${this.running.has(this.sessionKey(session, issue)) ? " (running)" : ""}.\n> session: \`${session.id}\` | workdir: \`${workdir}\``);
+      this.enqueueOrRun(session, issue, prompt, comment.id, model);
     }
     } finally {
       if (comment.id) this.processingComments.delete(comment.id);
@@ -474,10 +534,21 @@ export class Engine {
 
     let exitCode: number | null = null;
 
+    // M-1: build the child env explicitly. When a model IS resolved we push
+    // --model above, so opencode ignores OPENCODE_MODEL anyway. When NO model
+    // is resolved we must not let a leaked OPENCODE_MODEL from our own env
+    // silently win — strip it so opencode falls back to its opencode.json
+    // (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 };
+    if (!msg.model) delete childEnv.OPENCODE_MODEL;
+
     try {
       const proc = spawn({
         cmd: args,
         cwd: workdir,
+        env: childEnv,
         stdout: "pipe",
         stderr: "pipe",
         stdin: "ignore",