u-foo 1.0.3 → 1.1.9

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

@@ -0,0 +1,172 @@
+const fs = require("fs");
+const { getUfooPaths } = require("../ufoo/paths");
+const { spawn, spawnSync } = require("child_process");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+
+/**
+ * 激活指定 agent 的终端
+ *
+ * 支持的方式：
+ * - tmux: 使用 tmux select-pane 激活
+ * - terminal: 使用 AppleScript 通过 tty 定位并激活 Terminal.app 的 tab/window
+ * - internal: 不支持自动激活（由 chat PTY view 处理）
+ */
+class AgentActivator {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    const paths = getUfooPaths(projectRoot);
+    this.agentsFile = paths.agentsFile;
+  }
+
+  /**
+   * 获取 agent 信息
+   */
+  getAgentInfo(agentId) {
+    try {
+      if (!fs.existsSync(this.agentsFile)) {
+        throw new Error("Bus not initialized");
+      }
+
+      const busData = JSON.parse(fs.readFileSync(this.agentsFile, "utf8"));
+      const meta = busData.agents?.[agentId];
+
+      if (!meta) {
+        throw new Error(`Agent not found: ${agentId}`);
+      }
+
+      return {
+        id: agentId,
+        nickname: meta.nickname || "",
+        tty: meta.tty || "",
+        tmux_pane: meta.tmux_pane || "",
+        launch_mode: meta.launch_mode || "",
+      };
+    } catch (err) {
+      throw new Error(`Failed to get agent info: ${err.message}`);
+    }
+  }
+
+  /**
+   * 激活 tmux pane
+   */
+  activateTmuxPane(paneId) {
+    return new Promise((resolve, reject) => {
+      // 首先检查 pane 是否存在
+      const checkProc = spawn("tmux", ["list-panes", "-a", "-F", "#{pane_id}"]);
+      let output = "";
+
+      checkProc.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+
+      checkProc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error("tmux is not running"));
+          return;
+        }
+
+        const panes = output.trim().split("\n");
+        if (!panes.includes(paneId)) {
+          reject(new Error(`tmux pane not found: ${paneId}`));
+          return;
+        }
+
+        // 激活 pane（选择 window 和 pane）
+        const selectProc = spawn("tmux", ["select-pane", "-t", paneId]);
+
+        selectProc.on("close", (selectCode) => {
+          if (selectCode === 0) {
+            resolve();
+          } else {
+            reject(new Error("Failed to select tmux pane"));
+          }
+        });
+
+        selectProc.on("error", reject);
+      });
+
+      checkProc.on("error", reject);
+    });
+  }
+
+  /**
+   * 通过 tty 激活 Terminal.app 中对应的 tab/window
+   */
+  activateTerminalByTty(ttyPath) {
+    if (process.platform !== "darwin") {
+      throw new Error("Terminal activation is only supported on macOS");
+    }
+    if (!ttyPath) {
+      throw new Error("Cannot activate: tty path required");
+    }
+
+    const script = `
+tell application "Terminal"
+  repeat with w in windows
+    repeat with t in tabs of w
+      if tty of t is "${ttyPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}" then
+        set selected tab of w to t
+        set index of w to 1
+        activate
+        return "ok"
+      end if
+    end repeat
+  end repeat
+  return "not found"
+end tell`;
+
+    const result = spawnSync("osascript", ["-e", script], {
+      encoding: "utf8",
+      timeout: 5000,
+    });
+
+    if (result.status !== 0) {
+      throw new Error(`AppleScript failed: ${(result.stderr || "").trim()}`);
+    }
+
+    const output = (result.stdout || "").trim();
+    if (output === "not found") {
+      throw new Error(`Terminal tab not found for tty: ${ttyPath}`);
+    }
+  }
+
+  /**
+   * 激活 agent 的终端
+   */
+  async activate(agentId) {
+    const info = this.getAgentInfo(agentId);
+
+    const activateTerminal = async () => {
+      if (info.tty) {
+        this.activateTerminalByTty(info.tty);
+        return;
+      }
+      throw new Error("Cannot activate: missing tty or tmux_pane for agent");
+    };
+
+    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");
+    };
+
+    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");
+    }
+
+    await adapter.activate();
+  }
+}
+
+module.exports = AgentActivator;