u-foo 2.5.0 → 2.5.2

package/src/agents/prompts/defaultBootstrap.js

@@ -64,10 +64,25 @@ function buildDefaultStartupBootstrapPrompt({ agentType = "", projectRoot = "" }
     `Session bootstrap for ${displayAgent}.`,
     "Adopt the following ufoo coordination protocol silently.",
     "Do not reply to this bootstrap message unless the user explicitly asks about it. After applying it, continue the active task or wait for user input.",
-    SHARED_UFOO_PROTOCOL,
   ];
 
   const root = asTrimmedString(projectRoot) || process.cwd();
+  const requestedProfile = asTrimmedString(process.env.UFOO_PROMPT_PROFILE);
+  if (requestedProfile) {
+    try {
+      const { loadPromptProfileRegistry, resolvePromptProfileReference } = require("./promptProfiles");
+      const registry = loadPromptProfileRegistry(root);
+      const profile = resolvePromptProfileReference(registry, requestedProfile);
+      if (profile && profile.prompt) {
+        segments.push(`Your role: ${profile.id} (${profile.short_name || "Custom Role"}).\nAdopt the following role context:\n\n${profile.prompt}`);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  segments.push(SHARED_UFOO_PROTOCOL);
+
   const teamActivity = loadTeamActivityContext(root);
   if (teamActivity) {
     segments.push(teamActivity);

package/src/app/cli/busCoreCommands.js

@@ -39,6 +39,18 @@ function parseSendArgs(cmdArgs = []) {
   };
 }
 
+function resolvePollSubscriber(cmdArgs = [], env = process.env) {
+  const positionals = cmdArgs.filter((arg) => typeof arg === "string" && !arg.startsWith("--"));
+  const subscriber = String(positionals[0] || env.UFOO_SUBSCRIBER_ID || "").trim();
+  if (!subscriber) {
+    throw new Error("poll requires [subscriber] or UFOO_SUBSCRIBER_ID");
+  }
+  return {
+    subscriber,
+    autoAck: cmdArgs.includes("--ack") || cmdArgs.includes("--auto-ack"),
+  };
+}
+
 async function runBusCoreCommand(eventBus, cmd, cmdArgs = []) {
   switch (cmd) {
     case "init":
@@ -76,6 +88,12 @@ async function runBusCoreCommand(eventBus, cmd, cmdArgs = []) {
     case "check":
       await eventBus.check(cmdArgs[0]);
       return {};
+    case "poll":
+      {
+        const parsed = resolvePollSubscriber(cmdArgs);
+        await eventBus.check(parsed.subscriber, parsed.autoAck);
+      }
+      return {};
     case "ack":
       await eventBus.ack(cmdArgs[0]);
       return {};
@@ -99,4 +117,4 @@ async function runBusCoreCommand(eventBus, cmd, cmdArgs = []) {
   }
 }
 
-module.exports = { runBusCoreCommand };
+module.exports = { runBusCoreCommand, resolvePollSubscriber };

package/src/app/cli/run.js

@@ -1524,32 +1524,6 @@ async function runCli(argv) {
             process.exitCode = 1;
           });
       });
-    bus
-      .command("daemon")
-      .description("Start/stop daemon that auto-injects /bus into terminals")
-      .option("--interval <n>", "Poll interval in seconds", "2")
-      .option("--daemon", "Run in background")
-      .option("--stop", "Stop running daemon")
-      .option("--status", "Check daemon status")
-      .action((opts) => {
-        const EventBus = require("../../coordination/bus");
-        const eventBus = new EventBus(process.cwd());
-        (async () => {
-          try {
-            const interval = parseInt(opts.interval, 10) * 1000 || 2000;
-            if (opts.stop) {
-              await eventBus.daemon("stop");
-            } else if (opts.status) {
-              await eventBus.daemon("status");
-            } else {
-              await eventBus.daemon("start", { background: opts.daemon, interval });
-            }
-          } catch (err) {
-            console.error(err.message);
-            process.exitCode = 1;
-          }
-        })();
-      });
     bus
       .command("inject")
       .description("Inject /bus into a Terminal.app tab by subscriber ID")
@@ -1739,6 +1713,7 @@ async function runCli(argv) {
     console.log("  ufoo online send --nickname <name> --text <msg> [--channel <ch>] [--room <id>]");
     console.log("  ufoo online inbox <nickname> [--clear] [--unread]");
     console.log("  ufoo bus wake <target> [--reason <reason>] [--no-shake]");
+    console.log("  ufoo bus poll [subscriber] [--ack]");
     console.log("  ufoo bus <args...>    (JS bus implementation)");
     console.log("  ufoo ctx <subcmd> ... (doctor|lint|decisions|sync)");
     console.log("  ufoo history <build|show|prompt> [limit]");
@@ -2377,33 +2352,6 @@ async function runCli(argv) {
         });
       return;
     }
-    if (sub === "daemon") {
-      // 使用 JavaScript daemon
-      const EventBus = require("../../coordination/bus");
-      const eventBus = new EventBus(process.cwd());
-
-      (async () => {
-        try {
-          const hasStop = rest.includes("--stop");
-          const hasStatus = rest.includes("--status");
-          const hasDaemon = rest.includes("--daemon");
-          const intervalIdx = rest.indexOf("--interval");
-          const interval = intervalIdx !== -1 ? parseInt(rest[intervalIdx + 1], 10) * 1000 : 2000;
-
-          if (hasStop) {
-            await eventBus.daemon("stop");
-          } else if (hasStatus) {
-            await eventBus.daemon("status");
-          } else {
-            await eventBus.daemon("start", { background: hasDaemon, interval });
-          }
-        } catch (err) {
-          console.error(err.message);
-          process.exitCode = 1;
-        }
-      })();
-      return;
-    }
     if (sub === "inject") {
       // 使用 JavaScript inject
       const EventBus = require("../../coordination/bus");

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,
+};