u-foo 1.0.6 → 1.2.0

package/src/assistant/stdio.js

@@ -0,0 +1,58 @@
+const { runAssistantAgentTask } = require("./agent");
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.resume();
+  });
+}
+
+async function runAssistantStdio() {
+  const startedAt = Date.now();
+  try {
+    const input = await readStdin();
+    const line = String(input || "")
+      .split(/\r?\n/)
+      .map((part) => part.trim())
+      .find(Boolean);
+
+    if (!line) {
+      process.stdout.write(
+        `${JSON.stringify({
+          ok: false,
+          summary: "",
+          artifacts: [],
+          logs: [],
+          error: "missing request payload",
+          metrics: { duration_ms: Date.now() - startedAt },
+        })}\n`
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const payload = JSON.parse(line);
+    const result = await runAssistantAgentTask(payload);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.ok ? 0 : 1;
+  } catch (err) {
+    process.stdout.write(
+      `${JSON.stringify({
+        ok: false,
+        summary: "",
+        artifacts: [],
+        logs: [],
+        error: err && err.message ? err.message : "assistant stdio failed",
+        metrics: { duration_ms: Date.now() - startedAt },
+      })}\n`
+    );
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { runAssistantStdio };

package/src/assistant/ufooEngineCli.js

@@ -0,0 +1,306 @@
+const { runCliAgent } = require("../agent/cliRunner");
+const { normalizeCliOutput } = require("../agent/normalizeOutput");
+const { loadConfig } = require("../config");
+
+function normalizeProvider(value, fallback = "codex-cli") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return fallback;
+  if (raw === "codex" || raw === "codex-cli") return "codex-cli";
+  if (raw === "claude" || raw === "claude-cli") return "claude-cli";
+  return fallback;
+}
+
+function parseAssistantTaskArgs(argv = []) {
+  const options = {
+    assistantTask: false,
+    json: false,
+    cwd: "",
+    model: "",
+    sessionId: "",
+    provider: "",
+    kind: "mixed",
+    context: "",
+    expect: "",
+    task: "",
+  };
+
+  const args = Array.isArray(argv) ? argv.slice() : [];
+  const rest = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--assistant-task") {
+      options.assistantTask = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (arg === "--cwd") {
+      options.cwd = args[++i] || "";
+      continue;
+    }
+    if (arg === "--model") {
+      options.model = args[++i] || "";
+      continue;
+    }
+    if (arg === "--session-id") {
+      options.sessionId = args[++i] || "";
+      continue;
+    }
+    if (arg === "--provider") {
+      options.provider = args[++i] || "";
+      continue;
+    }
+    if (arg === "--kind") {
+      options.kind = args[++i] || "mixed";
+      continue;
+    }
+    if (arg === "--context") {
+      options.context = args[++i] || "";
+      continue;
+    }
+    if (arg === "--expect") {
+      options.expect = args[++i] || "";
+      continue;
+    }
+    rest.push(arg);
+  }
+  options.task = rest.join(" ").trim();
+  return options;
+}
+
+function buildPrompt({ kind = "mixed", context = "", task = "", expect = "" } = {}) {
+  const lines = [];
+  lines.push(`Task kind: ${kind || "mixed"}`);
+  if (context) {
+    lines.push("Context:");
+    lines.push(context);
+  }
+  lines.push("Task:");
+  lines.push(task || "");
+  if (expect) {
+    lines.push("Expected result:");
+    lines.push(expect);
+  }
+  return lines.join("\n");
+}
+
+function buildSystemPrompt() {
+  return [
+    "You are ufoo-engine, a self-hosted assistant core.",
+    "Return ONLY valid JSON.",
+    "Schema:",
+    "{",
+    '  "ok": true|false,',
+    '  "summary": "string",',
+    '  "artifacts": ["string"],',
+    '  "logs": ["string"],',
+    '  "error": "string",',
+    '  "metrics": {"key":"value"}',
+    "}",
+    "Rules:",
+    "- summary should be concise and actionable.",
+    "- error must be non-empty only when ok=false.",
+    "- Do not output markdown wrappers.",
+  ].join("\n");
+}
+
+function normalizeEngineResult(parsed, fallbackError = "") {
+  if (!parsed || typeof parsed !== "object") {
+    const text = String(parsed || "").trim();
+    if (text) {
+      return {
+        ok: true,
+        summary: text,
+        artifacts: [],
+        logs: [],
+        error: "",
+        metrics: {},
+      };
+    }
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: fallbackError || "ufoo-engine invalid response",
+      metrics: {},
+    };
+  }
+
+  return {
+    ok: parsed.ok !== false,
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+    logs: Array.isArray(parsed.logs) ? parsed.logs : [],
+    error: typeof parsed.error === "string" ? parsed.error : "",
+    metrics: parsed.metrics && typeof parsed.metrics === "object" ? parsed.metrics : {},
+  };
+}
+
+function isSessionError(errorText = "") {
+  const text = String(errorText || "").toLowerCase();
+  return text.includes("session id")
+    || text.includes("session-id")
+    || text.includes("already in use");
+}
+
+function parseStdinPayload(stdinText = "") {
+  const line = String(stdinText || "")
+    .split(/\r?\n/)
+    .map((part) => part.trim())
+    .find(Boolean);
+  if (!line) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+async function runEngineTask(taskInput, deps = {}) {
+  const {
+    runCliAgentImpl = runCliAgent,
+    normalizeCliOutputImpl = normalizeCliOutput,
+    loadConfigImpl = loadConfig,
+    env = process.env,
+    cwd = process.cwd(),
+  } = deps;
+
+  const projectRoot = taskInput.cwd || taskInput.projectRoot || cwd;
+  const config = loadConfigImpl(projectRoot);
+  const provider = normalizeProvider(
+    taskInput.provider || env.UFOO_UFOO_ENGINE_PROVIDER || config.agentProvider,
+    "codex-cli"
+  );
+  const model =
+    String(taskInput.model || "").trim()
+    || String(env.UFOO_UFOO_ENGINE_MODEL || "").trim()
+    || String(config.agentModel || "").trim()
+    || (provider === "claude-cli" ? "opus" : "");
+
+  const systemPrompt = buildSystemPrompt();
+  const prompt = buildPrompt({
+    kind: taskInput.kind,
+    context: taskInput.context,
+    task: taskInput.task,
+    expect: taskInput.expect,
+  });
+  const timeoutMs = Number.isFinite(taskInput.timeoutMs) ? taskInput.timeoutMs : 60000;
+
+  const runOnce = async (sessionId) => runCliAgentImpl({
+    provider,
+    model,
+    prompt,
+    systemPrompt,
+    sessionId: sessionId || undefined,
+    disableSession: false,
+    cwd: projectRoot,
+    timeoutMs,
+    sandbox: taskInput.kind === "explore" ? "read-only" : "workspace-write",
+  });
+
+  let cliRes = await runOnce(taskInput.sessionId || "");
+  if (!cliRes.ok && taskInput.sessionId && isSessionError(cliRes.error)) {
+    cliRes = await runOnce("");
+  }
+
+  if (!cliRes.ok) {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: cliRes.error || "ufoo-engine cli failed",
+      metrics: {},
+      session_id: "",
+    };
+  }
+
+  const normalized = normalizeCliOutputImpl(cliRes.output);
+  let parsed;
+  try {
+    parsed = JSON.parse(normalized);
+  } catch {
+    parsed = normalized;
+  }
+  const result = normalizeEngineResult(parsed);
+  return {
+    ...result,
+    session_id: cliRes.sessionId || "",
+  };
+}
+
+async function runUfooEngineCli({ argv = [], stdinText = "", deps = {} } = {}) {
+  const options = parseAssistantTaskArgs(argv);
+
+  let taskInput;
+  if (options.assistantTask) {
+    if (!options.task) {
+      const error = {
+        ok: false,
+        summary: "",
+        artifacts: [],
+        logs: [],
+        error: "missing task",
+        metrics: {},
+      };
+      return { exitCode: 1, output: `${JSON.stringify(error)}\n` };
+    }
+    taskInput = {
+      task: options.task,
+      kind: options.kind,
+      context: options.context,
+      expect: options.expect,
+      provider: options.provider,
+      model: options.model,
+      sessionId: options.sessionId,
+      cwd: options.cwd,
+      timeoutMs: 60000,
+    };
+  } else {
+    const payload = parseStdinPayload(stdinText);
+    if (!payload || typeof payload !== "object") {
+      const error = {
+        ok: false,
+        summary: "",
+        artifacts: [],
+        logs: [],
+        error: "missing request payload",
+        metrics: {},
+      };
+      return { exitCode: 1, output: `${JSON.stringify(error)}\n` };
+    }
+    taskInput = {
+      task: typeof payload.task === "string" ? payload.task : "",
+      kind: typeof payload.kind === "string" ? payload.kind : "mixed",
+      context: typeof payload.context === "string" ? payload.context : "",
+      expect: typeof payload.expect === "string" ? payload.expect : "",
+      provider: typeof payload.provider === "string" ? payload.provider : "",
+      model: typeof payload.model === "string" ? payload.model : "",
+      sessionId: typeof payload.session_id === "string" ? payload.session_id : "",
+      cwd: typeof payload.project_root === "string" ? payload.project_root : "",
+      timeoutMs: Number.isFinite(payload.timeout_ms) ? payload.timeout_ms : 60000,
+    };
+  }
+
+  const result = await runEngineTask(taskInput, deps);
+  const output = `${JSON.stringify(result)}\n`;
+  return {
+    exitCode: result.ok === false ? 1 : 0,
+    output,
+  };
+}
+
+module.exports = {
+  normalizeProvider,
+  parseAssistantTaskArgs,
+  buildPrompt,
+  buildSystemPrompt,
+  normalizeEngineResult,
+  parseStdinPayload,
+  runEngineTask,
+  runUfooEngineCli,
+  isSessionError,
+};

package/src/bus/activate.js

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const { getUfooPaths } = require("../ufoo/paths");
 const { spawn, spawnSync } = require("child_process");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 
 /**
  * 激活指定 agent 的终端
@@ -135,21 +136,36 @@ end tell`;
   async activate(agentId) {
     const info = this.getAgentInfo(agentId);
 
-    if (info.launch_mode === "internal" || info.launch_mode === "internal-pty") {
-      throw new Error("Internal mode agents cannot be activated (no terminal window)");
-    }
+    const activateTerminal = async () => {
+      if (info.tty) {
+        this.activateTerminalByTty(info.tty);
+        return;
+      }
+      throw new Error("Cannot activate: missing tty or tmux_pane for agent");
+    };
 
-    if (info.launch_mode === "tmux" && info.tmux_pane) {
-      await this.activateTmuxPane(info.tmux_pane);
-      return;
-    }
+    const activateTmux = async () => {
+      if (info.tmux_pane) {
+        await this.activateTmuxPane(info.tmux_pane);
+        return;
+      }
+      throw new Error("Cannot activate: missing tty or tmux_pane for agent");
+    };
 
-    if (info.launch_mode === "terminal" && info.tty) {
-      this.activateTerminalByTty(info.tty);
-      return;
+    const adapterRouter = createTerminalAdapterRouter({
+      activateTerminal,
+      activateTmux,
+    });
+    const adapter = adapterRouter.getAdapter({ launchMode: info.launch_mode, agentId });
+
+    if (!adapter.capabilities.supportsActivate) {
+      if (adapter.capabilities.supportsInternalQueueLoop) {
+        throw new Error("Internal mode agents cannot be activated (no terminal window)");
+      }
+      throw new Error("Cannot activate: missing tty or tmux_pane for agent");
     }
 
-    throw new Error("Cannot activate: missing tty or tmux_pane for agent");
+    await adapter.activate();
   }
 }
 

package/src/bus/daemon.js

@@ -3,6 +3,8 @@ const path = require("path");
 const { readJSON, writeJSON, isPidAlive, isAgentPidAlive, ensureDir, safeNameToSubscriber, subscriberToSafeName } = require("./utils");
 const Injector = require("./inject");
 const QueueManager = require("./queue");
+const MessageManager = require("./message");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 
 /**
  * Bus Daemon - 监控消息并自动注入命令
@@ -22,6 +24,7 @@ class BusDaemon {
 
     this.queueManager = new QueueManager(busDir);
     this.injector = new Injector(busDir, agentsFile);
+    this.adapterRouter = createTerminalAdapterRouter();
   }
 
   /**
@@ -198,6 +201,8 @@ class BusDaemon {
       return;
     }
 
+    const busData = readJSON(this.agentsFile) || { agents: {} };
+    const messageManager = new MessageManager(this.busDir, busData, this.queueManager);
     const subscribers = fs.readdirSync(queuesDir);
 
     for (const safeName of subscribers) {
@@ -206,6 +211,19 @@ class BusDaemon {
         continue;
       }
 
+      const subscriber = safeNameToSubscriber(safeName);
+      const meta = busData.agents?.[subscriber];
+      const launchMode = meta?.launch_mode || "";
+      // Delivery ownership:
+      // - notifier/injector: terminal/tmux
+      // - internal queue loop: internal/internal-pty
+      // Bus daemon only handles legacy/unknown launch modes.
+      const adapter = this.adapterRouter.getAdapter({ launchMode, agentId: subscriber });
+      const { supportsNotifierInjector, supportsInternalQueueLoop } = adapter.capabilities;
+      if (launchMode && (supportsNotifierInjector || supportsInternalQueueLoop)) {
+        continue;
+      }
+
       // 获取当前消息数
       let count = 0;
       if (fs.statSync(pendingFile).size > 0) {
@@ -217,14 +235,85 @@ class BusDaemon {
       const lastCount = this.getLastCount(safeName);
 
       // 如果有新消息，注入命令
-      if (count > lastCount) {
-        const subscriber = safeNameToSubscriber(safeName);
+      const wakePath = path.join(queuesDir, safeName, "wake");
+      const wakeActive = fs.existsSync(wakePath);
+
+      if (count > 0 || wakeActive) {
         const now = new Date().toISOString().split("T")[1].slice(0, 8);
-        console.log(`[daemon] ${now} New message for ${subscriber} (${lastCount} -> ${count})`);
+        const note = wakeActive && count <= lastCount ? " (wake)" : "";
+        console.log(`[daemon] ${now} New message for ${subscriber} (${lastCount} -> ${count})${note}`);
 
         try {
-          await this.injector.inject(subscriber);
-          console.log(`[daemon] Injected /bus into ${subscriber}`);
+          const agentType = String((meta && meta.agent_type) || "").trim().toLowerCase();
+          const isUfooCode = subscriber.startsWith("ufoo-code:")
+            || agentType === "ufoo-code"
+            || agentType === "ucode"
+            || agentType === "ufoo";
+          if (isUfooCode) {
+            // ufoo-code queue is consumed internally by ucode itself.
+            // Bus daemon should not inject any command/text into terminal.
+            if (wakeActive) fs.rmSync(wakePath, { force: true });
+            this.setLastCount(safeName, count);
+            continue;
+          }
+
+          const events = this.drainPending(pendingFile);
+          const failed = [];
+          for (const evt of events) {
+            if (!evt || evt.event !== "message" || !evt.data || typeof evt.data.message !== "string") {
+              continue;
+            }
+            try {
+              // eslint-disable-next-line no-await-in-loop
+              await this.injector.inject(subscriber, String(evt.data.message));
+            } catch (err) {
+              failed.push(evt);
+              try {
+                const pub = typeof evt.publisher === "object" && evt.publisher
+                  ? (evt.publisher.subscriber || evt.publisher.nickname || "")
+                  : (evt.publisher || "");
+                if (pub) {
+                  // eslint-disable-next-line no-await-in-loop
+                  await messageManager.emit(pub, "delivery", {
+                    target: subscriber,
+                    seq: evt.seq,
+                    status: "error",
+                    message: `delivery failed to ${meta?.nickname || subscriber}: ${err.message || "inject failed"}`,
+                  }, subscriber, "status/delivery");
+                }
+              } catch {
+                // ignore delivery emit errors
+              }
+              continue;
+            }
+            try {
+              // Emit delivery status back to publisher (best-effort)
+              const pub = typeof evt.publisher === "object" && evt.publisher
+                ? (evt.publisher.subscriber || evt.publisher.nickname || "")
+                : (evt.publisher || "");
+              if (pub) {
+                // eslint-disable-next-line no-await-in-loop
+                await messageManager.emit(pub, "delivery", {
+                  target: subscriber,
+                  seq: evt.seq,
+                  status: "ok",
+                  message: `delivered to ${meta?.nickname || subscriber}`,
+                }, subscriber, "status/delivery");
+              }
+            } catch {
+              // ignore delivery emit errors
+            }
+          }
+          if (failed.length > 0) {
+            try {
+              const content = failed.map((e) => JSON.stringify(e)).join("\n") + "\n";
+              fs.appendFileSync(pendingFile, content, "utf8");
+            } catch {
+              // ignore requeue failures
+            }
+          }
+          console.log(`[daemon] Delivered ${events.length} message(s) to ${subscriber}`);
+          if (wakeActive) fs.rmSync(wakePath, { force: true });
         } catch (err) {
           console.error(`[daemon] Failed to inject: ${err.message}`);
         }
@@ -235,6 +324,45 @@ class BusDaemon {
     }
   }
 
+  drainPending(pendingFile) {
+    if (!fs.existsSync(pendingFile)) return [];
+    const processingFile = `${pendingFile}.processing.${process.pid}.${Date.now()}`;
+    let content = "";
+    let readOk = false;
+    try {
+      fs.renameSync(pendingFile, processingFile);
+      content = fs.readFileSync(processingFile, "utf8");
+      readOk = true;
+    } catch {
+      try {
+        if (fs.existsSync(processingFile)) {
+          fs.renameSync(processingFile, pendingFile);
+        }
+      } catch {
+        // ignore rollback errors
+      }
+      return [];
+    } finally {
+      if (readOk) {
+        try {
+          if (fs.existsSync(processingFile)) {
+            fs.rmSync(processingFile, { force: true });
+          }
+        } catch {
+          // ignore cleanup errors
+        }
+      }
+    }
+    if (!content.trim()) return [];
+    return content.split(/\r?\n/).filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+
   /**
    * 获取上次的消息计数
    */