u-foo 2.5.1 → 2.5.2

package/src/code/agent.js

@@ -31,6 +31,7 @@ const {
   listUcodeSkills,
   showSkill,
 } = require("./skills");
+const { DeliveryQueue } = require("../coordination/bus/deliveryQueue");
 
 function printPrompt() {
   process.stdout.write("> ");
@@ -883,110 +884,31 @@ function getPendingBusCount(workspaceRoot = process.cwd(), subscriberId = "") {
 function drainJsonlFile(filePath = "") {
   const target = String(filePath || "").trim();
   if (!target) return { drained: [], rawLines: [], error: "" };
-  if (!fs.existsSync(target)) return { drained: [], rawLines: [], error: "" };
-
-  const processingFile = `${target}.processing.${process.pid}.${Date.now()}`;
-  let content = "";
-  let renamed = false;
+  const queue = new DeliveryQueue(target);
+  const drained = [];
+  const rawLines = [];
+  const claims = [];
   try {
-    fs.renameSync(target, processingFile);
-    renamed = true;
-    content = String(fs.readFileSync(processingFile, "utf8") || "");
-  } catch (err) {
-    // Restore on failure.
-    try {
-      if (renamed && fs.existsSync(processingFile)) {
-        fs.renameSync(processingFile, target);
-      }
-    } catch {
-      // ignore
+    queue.recover();
+    while (true) {
+      const claim = queue.claimNext();
+      if (!claim) break;
+      claims.push(claim);
+      drained.push(claim.event);
+      rawLines.push(JSON.stringify(claim.event));
+      queue.completeClaim(claim);
     }
+  } catch (err) {
+    for (const claim of claims) queue.restoreClaim(claim);
     return { drained: [], rawLines: [], error: err && err.message ? err.message : "drain failed" };
   }
-
-  const rawLines = content.split(/\r?\n/).filter((line) => line.trim());
-  const drained = rawLines.map((line) => {
-    try {
-      return JSON.parse(line);
-    } catch {
-      return null;
-    }
-  }).filter(Boolean);
-
-  // Keep processing file around for potential requeue decisions by caller.
-  return { drained, rawLines, error: "", processingFile };
-}
-
-function requeueJsonlLines(filePath = "", lines = []) {
-  const target = String(filePath || "").trim();
-  const list = Array.isArray(lines) ? lines.filter((l) => String(l || "").trim()) : [];
-  if (!target || list.length === 0) return;
-  try {
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.appendFileSync(target, `${list.join("\n")}\n`, "utf8");
-  } catch {
-    // ignore requeue errors
-  }
-}
-
-function cleanupProcessingFile(filePath = "") {
-  const target = String(filePath || "").trim();
-  if (!target) return;
-  try {
-    if (fs.existsSync(target)) fs.rmSync(target, { force: true });
-  } catch {
-    // ignore
-  }
-}
-
-function recoverStaleProcessingFiles(pendingFilePath = "", options = {}) {
-  const pendingFile = String(pendingFilePath || "").trim();
-  if (!pendingFile) return 0;
-  const maxAgeMs = Number.isFinite(options.maxAgeMs) ? options.maxAgeMs : 30000;
-  const dir = path.dirname(pendingFile);
-  const base = path.basename(pendingFile);
-  const prefix = `${base}.processing.`;
-  const now = Date.now();
-  let recovered = 0;
-
-  try {
-    if (!fs.existsSync(dir)) return 0;
-    const names = fs.readdirSync(dir);
-    for (const name of names) {
-      if (!name || !name.startsWith(prefix)) continue;
-      const fullPath = path.join(dir, name);
-      let stat = null;
-      try {
-        stat = fs.statSync(fullPath);
-      } catch {
-        continue;
-      }
-      if (!stat || !stat.isFile()) continue;
-      const pidMatch = name.match(/\.processing\.(\d+)\./);
-      const pid = pidMatch ? parseInt(pidMatch[1], 10) : NaN;
-      const pidDead = Number.isFinite(pid) && pid > 0 && !isPidAlive(pid);
-      const tooOld = Number.isFinite(maxAgeMs) && maxAgeMs > 0 && (now - stat.mtimeMs >= maxAgeMs);
-      if (!pidDead && !tooOld) continue;
-
-      let content = "";
-      try {
-        content = String(fs.readFileSync(fullPath, "utf8") || "");
-      } catch {
-        content = "";
-      }
-
-      const lines = content.split(/\r?\n/).filter((line) => String(line || "").trim());
-      if (lines.length > 0) {
-        requeueJsonlLines(pendingFile, lines);
-      }
-      cleanupProcessingFile(fullPath);
-      recovered += 1;
-    }
-  } catch {
-    return recovered;
-  }
-
-  return recovered;
+  return {
+    drained,
+    rawLines,
+    error: "",
+    claims,
+    processingFile: claims[0] ? claims[0].processingFile : "",
+  };
 }
 
 function extractTaskFromBusEvent(evt) {
@@ -1144,39 +1066,22 @@ async function runUbusCommand(state = {}, options = {}) {
 
   // Prefer consuming pending.jsonl directly (stable, ANSI/wrapping-proof).
   const pendingFile = resolvePendingQueueFile(runtimeWorkspace, subscriberId);
-  // Recover any stale processing files from prior crashes so they don't "black hole" messages.
-  recoverStaleProcessingFiles(pendingFile, { maxAgeMs: 30000 });
+  const queue = pendingFile ? new DeliveryQueue(pendingFile) : null;
+  if (queue) queue.recover();
   const hasPendingFile = Boolean(pendingFile && fs.existsSync(pendingFile));
-  const drainedRes = hasPendingFile ? drainJsonlFile(pendingFile) : { drained: [], rawLines: [], error: "", processingFile: "" };
-  if (drainedRes && drainedRes.error) {
-    return {
-      ok: false,
-      summary: "",
-      error: drainedRes.error,
-      handled: 0,
-      subscriberId,
-    };
-  }
-  const rawLines = Array.isArray(drainedRes.rawLines) ? drainedRes.rawLines : [];
-  const messages = rawLines
-    .map((rawLine) => {
-      try {
-        const evt = JSON.parse(rawLine);
-        const msg = extractTaskFromBusEvent(evt);
-        if (!msg) return null;
-        return { ...msg, rawLine };
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
   let handled = 0;
   const sendErrors = [];
-  const failedRawLines = [];
   const messageExchanges = [];
 
-  try {
-    for (const message of messages) {
+  if (queue && hasPendingFile) {
+    while (fs.existsSync(pendingFile)) {
+      const claim = queue.claimNext();
+      if (!claim) break;
+      const message = extractTaskFromBusEvent(claim.event);
+      if (!message) {
+        queue.completeClaim(claim);
+        continue;
+      }
       let nlResult;
 
       // Notify that we received the message (for immediate display)
@@ -1200,32 +1105,28 @@ async function runUbusCommand(state = {}, options = {}) {
           signal: options.signal,
         });
       } catch (err) {
-        sendErrors.push(`task from ${message.publisher} failed: ${err && err.message ? err.message : "task failed"}`);
-        failedRawLines.push(message.rawLine);
+        const errorMessage = err && err.message ? err.message : "task failed";
+        sendErrors.push(`task from ${message.publisher} failed: ${errorMessage}`);
+        queue.restoreClaim(claim);
         // Send error notification
-        shell(`ufoo bus send ${shellQuote(message.publisher)} ${shellQuote(`❌ Error: ${err.message}`)}`);
-        continue;
+        shell(`ufoo bus send ${shellQuote(message.publisher)} ${shellQuote(`❌ Error: ${errorMessage}`)}`);
+        break;
       }
       const reply = String(formatNl(nlResult, false) || "").replace(/\s+/g, " ").trim() || "Done.";
       const sendRes = shell(`ufoo bus send ${shellQuote(message.publisher)} ${shellQuote(reply.slice(0, 2000))}`);
       if (!sendRes.ok) {
         sendErrors.push(`reply to ${message.publisher} failed: ${sendRes.error || "send failed"}`);
-        failedRawLines.push(message.rawLine);
-        continue;
+        queue.restoreClaim(claim);
+        break;
       }
       handled += 1;
+      queue.completeClaim(claim);
       messageExchanges.push({
         from: message.publisher,
         task: message.task,
         reply,
       });
     }
-  } finally {
-    // If we drained the pending file but had failures, requeue only failed lines.
-    if (failedRawLines.length > 0) {
-      requeueJsonlLines(pendingFile, failedRawLines);
-    }
-    cleanupProcessingFile(drainedRes.processingFile);
   }
 
   // Fallback: if there is no pending file, fall back to CLI `bus check` parsing.

package/src/coordination/bus/deliveryQueue.js

@@ -0,0 +1,308 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  ensureDir,
+  appendJSONL,
+  generateInstanceId,
+  readJSONL,
+  writeFileAtomic,
+  subscriberToSafeName,
+  isPidAlive,
+} = require("./utils");
+
+const PROCESSING_STALE_MS = 30000;
+
+function positiveSeq(event) {
+  const seq = Number(event && event.seq);
+  return Number.isFinite(seq) && seq > 0 ? seq : 0;
+}
+
+function eventToJsonl(events = []) {
+  const lines = events
+    .filter(Boolean)
+    .map((event) => JSON.stringify(event));
+  return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+}
+
+function readJsonlLoose(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, "utf8");
+  if (!content.trim()) return [];
+  return content.split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+const QUEUE_TYPES = {
+  AGENT_MESSAGE: "agent_message",
+  DAEMON_CONTROL: "daemon_control",
+  REPORT: "report",
+  WAKE: "wake",
+  DELIVERY_STATUS: "delivery_status",
+  EVENT: "event",
+};
+
+function inferQueueType(event = {}) {
+  if (event.queue_type) return String(event.queue_type);
+  if (event.event === "message") return QUEUE_TYPES.AGENT_MESSAGE;
+  if (event.event === "wake") return QUEUE_TYPES.WAKE;
+  if (event.event === "delivery") return QUEUE_TYPES.DELIVERY_STATUS;
+  if (event.type === "report/control" || event.event === "controller_report") return QUEUE_TYPES.REPORT;
+  if (String(event.target || "") === "ufoo-agent") return QUEUE_TYPES.DAEMON_CONTROL;
+  return QUEUE_TYPES.EVENT;
+}
+
+function defaultDeliveryForType(queueType) {
+  if (queueType === QUEUE_TYPES.AGENT_MESSAGE) {
+    return { mode: "inject", gate: "idle", max_inflight: 1 };
+  }
+  if (queueType === QUEUE_TYPES.WAKE) {
+    return { mode: "notify_only", gate: "none", max_inflight: 1 };
+  }
+  if (queueType === QUEUE_TYPES.DAEMON_CONTROL || queueType === QUEUE_TYPES.REPORT || queueType === QUEUE_TYPES.DELIVERY_STATUS) {
+    return { mode: "daemon_consume", gate: "none", max_inflight: 1 };
+  }
+  return { mode: "self_consume", gate: "none", max_inflight: 1 };
+}
+
+function defaultAckForType(queueType) {
+  if (queueType === QUEUE_TYPES.AGENT_MESSAGE) return { policy: "on_delivery" };
+  if (queueType === QUEUE_TYPES.WAKE) return { policy: "fire_and_forget" };
+  return { policy: "on_consume" };
+}
+
+function normalizeQueueEnvelope(event = {}, overrides = {}) {
+  const queueType = overrides.queueType || overrides.queue_type || inferQueueType(event);
+  const existingDelivery = event.delivery && typeof event.delivery === "object" ? event.delivery : {};
+  const overrideDelivery = overrides.delivery && typeof overrides.delivery === "object" ? overrides.delivery : {};
+  const existingAck = event.ack && typeof event.ack === "object" ? event.ack : {};
+  const overrideAck = overrides.ack && typeof overrides.ack === "object" ? overrides.ack : {};
+  return {
+    ...event,
+    queue_type: queueType,
+    delivery: {
+      ...defaultDeliveryForType(queueType),
+      ...existingDelivery,
+      ...overrideDelivery,
+    },
+    ack: {
+      ...defaultAckForType(queueType),
+      ...existingAck,
+      ...overrideAck,
+    },
+  };
+}
+
+function stripQueueEnvelope(event = {}) {
+  if (!event || typeof event !== "object") return event;
+  const stripped = { ...event };
+  delete stripped.queue_type;
+  delete stripped.delivery;
+  delete stripped.ack;
+  return stripped;
+}
+
+class DeliveryQueue {
+  constructor(pendingFile) {
+    this.pendingFile = pendingFile;
+  }
+
+  static forSubscriber(busDir, subscriber) {
+    return new DeliveryQueue(path.join(
+      busDir,
+      "queues",
+      subscriberToSafeName(subscriber),
+      "pending.jsonl"
+    ));
+  }
+
+  queueDir() {
+    return path.dirname(this.pendingFile);
+  }
+
+  ensureQueueDir() {
+    ensureDir(this.queueDir());
+  }
+
+  processingPatternPrefix() {
+    return `${path.basename(this.pendingFile)}.processing.`;
+  }
+
+  processingFiles() {
+    const dir = this.queueDir();
+    if (!fs.existsSync(dir)) return [];
+    const prefix = this.processingPatternPrefix();
+    return fs.readdirSync(dir)
+      .filter((name) => name.startsWith(prefix))
+      .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }))
+      .map((name) => path.join(dir, name));
+  }
+
+  processingFileInfo(filePath) {
+    const name = path.basename(filePath || "");
+    const escapedBase = path.basename(this.pendingFile).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = name.match(new RegExp(`^${escapedBase}\\.processing\\.(\\d+)(?:\\.(\\d+))?`));
+    const pid = match ? parseInt(match[1], 10) : NaN;
+    const timestamp = match && match[2] ? parseInt(match[2], 10) : NaN;
+    return {
+      pid: Number.isFinite(pid) && pid > 0 ? pid : 0,
+      timestamp: Number.isFinite(timestamp) && timestamp > 0 ? timestamp : 0,
+    };
+  }
+
+  isRecoverableProcessingFile(filePath, options = {}) {
+    const maxAgeMs = Number.isFinite(options.maxAgeMs) ? options.maxAgeMs : PROCESSING_STALE_MS;
+    const info = this.processingFileInfo(filePath);
+    if (info.pid > 0) return !isPidAlive(info.pid);
+    if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) return false;
+
+    const now = Date.now();
+    if (info.timestamp > 0 && now - info.timestamp >= maxAgeMs) return true;
+
+    try {
+      const stat = fs.statSync(filePath);
+      return Boolean(stat && stat.isFile() && now - stat.mtimeMs >= maxAgeMs);
+    } catch {
+      return false;
+    }
+  }
+
+  readPending() {
+    this.recover();
+    return readJSONL(this.pendingFile);
+  }
+
+  readPendingRaw() {
+    return readJSONL(this.pendingFile);
+  }
+
+  append(event) {
+    if (!event) return;
+    this.ensureQueueDir();
+    appendJSONL(this.pendingFile, normalizeQueueEnvelope(event));
+  }
+
+  writePending(events = []) {
+    this.ensureQueueDir();
+    const items = Array.isArray(events) ? events.filter(Boolean) : [];
+    if (items.length === 0) {
+      try {
+        fs.rmSync(this.pendingFile, { force: true });
+      } catch {
+        // ignore cleanup errors
+      }
+      return;
+    }
+    writeFileAtomic(this.pendingFile, eventToJsonl(items));
+  }
+
+  mergeAndSort(events = []) {
+    const sequenced = new Map();
+    const unsequenced = [];
+    for (const event of events) {
+      if (!event) continue;
+      const seq = positiveSeq(event);
+      if (seq > 0) {
+        if (!sequenced.has(seq)) sequenced.set(seq, event);
+      } else {
+        unsequenced.push(event);
+      }
+    }
+    return [
+      ...Array.from(sequenced.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([, event]) => event),
+      ...unsequenced,
+    ];
+  }
+
+  recover(options = {}) {
+    const files = this.processingFiles()
+      .filter((file) => this.isRecoverableProcessingFile(file, options));
+    if (files.length === 0) return { recovered: 0, files: [] };
+
+    const all = [...this.readPendingRaw()];
+    for (const file of files) {
+      all.push(...readJsonlLoose(file));
+    }
+
+    const merged = this.mergeAndSort(all);
+    this.writePending(merged);
+
+    for (const file of files) {
+      try {
+        fs.rmSync(file, { force: true });
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+
+    return { recovered: merged.length, files };
+  }
+
+  claimNext() {
+    this.recover();
+    const pending = this.readPendingRaw();
+    if (pending.length === 0) return null;
+
+    const event = pending[0];
+    const remaining = pending.slice(1);
+    const processingFile = `${this.pendingFile}.processing.${process.pid}.${Date.now()}.${generateInstanceId()}`;
+    this.ensureQueueDir();
+    writeFileAtomic(processingFile, eventToJsonl([event]));
+    this.writePending(remaining);
+
+    return {
+      event,
+      processingFile,
+      pendingFile: this.pendingFile,
+    };
+  }
+
+  completeClaim(claim) {
+    const processingFile = claim && claim.processingFile;
+    if (!processingFile) return false;
+    try {
+      if (fs.existsSync(processingFile)) {
+        fs.rmSync(processingFile, { force: true });
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    return false;
+  }
+
+  restoreClaim(claim) {
+    const event = claim && claim.event;
+    const processingFile = claim && claim.processingFile;
+    if (!event) return false;
+
+    const merged = this.mergeAndSort([event, ...this.readPendingRaw()]);
+    this.writePending(merged);
+    if (processingFile) {
+      try {
+        fs.rmSync(processingFile, { force: true });
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+    return true;
+  }
+}
+
+module.exports = {
+  DeliveryQueue,
+  QUEUE_TYPES,
+  normalizeQueueEnvelope,
+  stripQueueEnvelope,
+  inferQueueType,
+  positiveSeq,
+};

package/src/coordination/bus/index.js

@@ -21,7 +21,6 @@ const QueueManager = require("./queue");
 const SubscriberManager = require("./subscriber");
 const MessageManager = require("./message");
 const NicknameManager = require("./nickname");
-const BusDaemon = require("./daemon");
 const Injector = require("./inject");
 const { BusStore } = require("./store");
 
@@ -263,7 +262,7 @@ class EventBus {
       }
     }
 
-    logError("Not joined to bus. Please run: ufoo bus join");
+    logError("Not joined to bus. Launch through ufoo wrappers or register through MCP.");
     return null;
   }
 
@@ -764,10 +763,9 @@ class EventBus {
 
       if (countAfter > countBefore) {
         await sleep(50);
-        const daemon = new BusDaemon(this.busDir, this.agentsFile, this.paths.busDaemonDir, 2000, this.projectRoot);
-        await daemon.injector.inject(target, options.command || "");
+        await this.injector.inject(target, options.command || "");
         if (options.shake !== false) {
-          const tty = daemon.injector.readTty(target);
+          const tty = this.injector.readTty(target);
           if (tty) shakeTerminalByTty(tty, { skipFrontmost: true });
         }
       }
@@ -857,28 +855,6 @@ class EventBus {
     }
   }
 
-  /**
-   * Daemon 管理
-   */
-  async daemon(action, options = {}) {
-    const interval = options.interval || 2000;
-    const daemon = new BusDaemon(this.busDir, this.agentsFile, this.paths.busDaemonDir, interval, this.projectRoot);
-
-    switch (action) {
-      case "start":
-        await daemon.start(options.background || false);
-        break;
-      case "stop":
-        daemon.stop();
-        break;
-      case "status":
-        daemon.status();
-        break;
-      default:
-        throw new Error(`Unknown daemon action: ${action}`);
-    }
-  }
-
   /**
    * 注入命令到订阅者终端
    */