agentmomo 0.1.2 → 0.2.1

package/dist/codex-cli-hook.cjs

@@ -0,0 +1,415 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// proxy/codex-cli-hook.ts
+var import_http = __toESM(require("http"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var AGENTMOMO_PORT = 9001;
+var TIMEOUT_MS = 1500;
+var LOG_FILE = import_path.default.join(
+  process.env.USERPROFILE ?? process.env.HOME ?? ".",
+  ".agentmomo-hook.log"
+);
+var ROLE_LABELS = {
+  reader: "Reader",
+  writer: "Writer",
+  runner: "Runner",
+  searcher: "Searcher"
+};
+var pendingItems = /* @__PURE__ */ new Map();
+var threadCwd = /* @__PURE__ */ new Map();
+var registeredThreads = /* @__PURE__ */ new Set();
+function readArg(name) {
+  const idx = process.argv.indexOf(name);
+  if (idx !== -1 && process.argv[idx + 1]) {
+    return process.argv[idx + 1].replace(/^['\"]+|['\"]+$/g, "");
+  }
+  return void 0;
+}
+var AGENTMOMO_API_KEY = readArg("--api-key") ?? process.env.AGENTMOMO_API_KEY ?? "";
+function log(msg) {
+  try {
+    import_fs.default.appendFileSync(
+      LOG_FILE,
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] [codex] ${msg}
+`
+    );
+  } catch {
+  }
+}
+function postEvent(body) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  };
+  if (AGENTMOMO_API_KEY) {
+    headers.Authorization = `Bearer ${AGENTMOMO_API_KEY}`;
+  }
+  const req = import_http.default.request(
+    {
+      hostname: "localhost",
+      port: AGENTMOMO_PORT,
+      path: "/api/event",
+      method: "POST",
+      headers,
+      timeout: TIMEOUT_MS
+    },
+    (res) => {
+      if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+        let responseBody = "";
+        res.on("data", (chunk) => {
+          responseBody += chunk.toString();
+        });
+        res.on("end", () => {
+          log(`POST /api/event failed ${res.statusCode}: ${responseBody}`);
+        });
+      } else {
+        res.resume();
+      }
+    }
+  );
+  req.on("error", (err) => {
+    log(`POST error: ${err.message}`);
+  });
+  req.on("timeout", () => {
+    req.destroy();
+  });
+  req.write(body);
+  req.end();
+}
+function isEventType(actual, expected) {
+  if (typeof actual !== "string") return false;
+  return actual === expected || actual === expected.replace(".", "/");
+}
+function normalizeItemType(raw) {
+  if (typeof raw !== "string") return "unknown";
+  return raw.replace(/[\s_-]+/g, "").toLowerCase();
+}
+function getTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return Date.now();
+}
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function pickThreadId(payload) {
+  const params = asRecord(payload.params);
+  const item = asRecord(payload.item) ?? asRecord(params?.item);
+  const threadValue = payload.thread_id ?? payload.threadId ?? params?.threadId ?? item?.thread_id ?? item?.threadId;
+  return typeof threadValue === "string" && threadValue.trim() ? threadValue : "codex-thread";
+}
+function pickTurnId(payload) {
+  const params = asRecord(payload.params);
+  const item = asRecord(payload.item) ?? asRecord(params?.item);
+  const turnValue = payload.turn_id ?? payload.turnId ?? params?.turnId ?? item?.turn_id ?? item?.turnId;
+  return typeof turnValue === "string" && turnValue.trim() ? turnValue : void 0;
+}
+function pickCwd(payload) {
+  const params = asRecord(payload.params);
+  const item = asRecord(payload.item) ?? asRecord(params?.item);
+  const cwdValue = payload.cwd ?? params?.cwd ?? item?.cwd;
+  return typeof cwdValue === "string" && cwdValue.trim() ? cwdValue : void 0;
+}
+function getAgentIdentity(threadId, cwd, role) {
+  const folderName = cwd ? import_path.default.basename(cwd) : "Codex CLI";
+  const cwdSlug = folderName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 16) || "project";
+  return {
+    agentId: `cx-${cwdSlug}-${role}`,
+    agentName: `${folderName} \xB7 ${ROLE_LABELS[role]}`
+  };
+}
+function truncate(value, max = 120) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1)}\u2026`;
+}
+function extractCommandLabel(command) {
+  if (typeof command === "string" && command.trim()) {
+    return truncate(command.trim());
+  }
+  if (Array.isArray(command)) {
+    const tokens = command.filter((v) => typeof v === "string");
+    if (tokens.length > 0) return truncate(tokens.join(" "));
+  }
+  const commandObj = asRecord(command);
+  if (commandObj) {
+    if (Array.isArray(commandObj.argv)) {
+      const tokens = commandObj.argv.filter(
+        (v) => typeof v === "string"
+      );
+      if (tokens.length > 0) return truncate(tokens.join(" "));
+    }
+    if (typeof commandObj.command === "string" && commandObj.command.trim()) {
+      return truncate(commandObj.command.trim());
+    }
+  }
+  return "shell";
+}
+function deriveItemInfo(item) {
+  const rawType = item.type ?? item.item_type;
+  const itemType = normalizeItemType(rawType);
+  if (itemType === "commandexecution") {
+    return {
+      role: "runner",
+      toolName: extractCommandLabel(item.command),
+      itemType: "command_execution",
+      threadId: "codex-thread"
+    };
+  }
+  if (itemType === "filechange") {
+    return {
+      role: "writer",
+      toolName: "file_change",
+      itemType: "file_change",
+      threadId: "codex-thread"
+    };
+  }
+  if (itemType === "mcptoolcall") {
+    const server = typeof item.server === "string" ? item.server : "mcp";
+    const tool = typeof item.tool === "string" ? item.tool : "tool";
+    return {
+      role: "runner",
+      toolName: `${server}.${tool}`,
+      itemType: "mcp_tool_call",
+      threadId: "codex-thread"
+    };
+  }
+  if (itemType === "websearch") {
+    return {
+      role: "searcher",
+      toolName: "web_search",
+      itemType: "web_search",
+      threadId: "codex-thread"
+    };
+  }
+  if (itemType === "dynamictoolcall") {
+    const tool = typeof item.tool === "string" && item.tool.trim() ? item.tool : "dynamic_tool";
+    return {
+      role: "runner",
+      toolName: tool,
+      itemType: "dynamic_tool_call",
+      threadId: "codex-thread"
+    };
+  }
+  return null;
+}
+function emitEvent(event) {
+  postEvent(JSON.stringify(event));
+}
+function ensureThreadRegistered(threadId, cwd, timestamp) {
+  if (registeredThreads.has(threadId)) return;
+  registeredThreads.add(threadId);
+  const identity = getAgentIdentity(threadId, cwd, "runner");
+  emitEvent({
+    agentId: identity.agentId,
+    agentName: identity.agentName,
+    source: "codex-cli",
+    event: "agent_register",
+    toolName: "",
+    timestamp,
+    requestId: `${threadId}-register-${timestamp}`,
+    metadata: {
+      threadId,
+      cwd: cwd ?? "unknown",
+      provider: "codex-cli"
+    }
+  });
+}
+function handlePayload(payload) {
+  const type = payload.type;
+  const timestamp = getTimestamp(payload.timestamp);
+  const threadId = pickThreadId(payload);
+  const turnId = pickTurnId(payload);
+  const cwd = pickCwd(payload) ?? threadCwd.get(threadId);
+  if (cwd) threadCwd.set(threadId, cwd);
+  if (isEventType(type, "thread.started") || isEventType(type, "turn.started")) {
+    ensureThreadRegistered(threadId, cwd, timestamp);
+    const identity = getAgentIdentity(threadId, cwd, "runner");
+    emitEvent({
+      agentId: identity.agentId,
+      agentName: identity.agentName,
+      source: "codex-cli",
+      event: "agent_heartbeat",
+      toolName: "",
+      timestamp,
+      requestId: `${threadId}-heartbeat-${timestamp}`,
+      metadata: {
+        threadId,
+        turnId,
+        cwd: cwd ?? "unknown",
+        codexEventType: type
+      }
+    });
+    return;
+  }
+  if (isEventType(type, "turn.failed") || isEventType(type, "error")) {
+    ensureThreadRegistered(threadId, cwd, timestamp);
+    const identity = getAgentIdentity(threadId, cwd, "runner");
+    const errObj = asRecord(payload.error);
+    const errMsg = typeof errObj?.message === "string" && errObj.message || typeof payload.message === "string" && payload.message || "Codex turn failed";
+    emitEvent({
+      agentId: identity.agentId,
+      agentName: identity.agentName,
+      source: "codex-cli",
+      event: "call_error",
+      toolName: "turn",
+      timestamp,
+      requestId: `${threadId}-turn-failed-${timestamp}`,
+      error: errMsg,
+      metadata: {
+        threadId,
+        turnId,
+        cwd: cwd ?? "unknown",
+        codexEventType: type
+      }
+    });
+    return;
+  }
+  if (isEventType(type, "item.started") || isEventType(type, "item.completed")) {
+    const params = asRecord(payload.params);
+    const item = asRecord(payload.item) ?? asRecord(params?.item);
+    if (!item) return;
+    if (isEventType(type, "item.completed")) {
+      const rawItemType = normalizeItemType(item.type ?? item.item_type);
+      const isLlmText = rawItemType === "agentmessage" || rawItemType === "message" || rawItemType === "reasoning";
+      const textContent = typeof item.text === "string" ? item.text.trim() : typeof item.content === "string" ? item.content.trim() : void 0;
+      if (isLlmText && textContent) {
+        ensureThreadRegistered(threadId, cwd, timestamp);
+        const identity2 = getAgentIdentity(threadId, cwd, "runner");
+        emitEvent({
+          agentId: identity2.agentId,
+          agentName: identity2.agentName,
+          source: "codex-cli",
+          event: "agent_message",
+          toolName: "",
+          message: textContent,
+          timestamp,
+          requestId: `${threadId}-msg-${timestamp}`,
+          metadata: {
+            threadId,
+            turnId,
+            cwd: cwd ?? "unknown",
+            codexEventType: type
+          }
+        });
+        return;
+      }
+    }
+    const itemIdValue = item.id ?? payload.item_id ?? params?.itemId;
+    const itemId = typeof itemIdValue === "string" && itemIdValue.trim() ? itemIdValue : void 0;
+    const derived = deriveItemInfo(item);
+    if (!derived || !itemId) return;
+    const itemInfo = {
+      ...derived,
+      threadId,
+      turnId,
+      cwd
+    };
+    ensureThreadRegistered(threadId, cwd, timestamp);
+    const identity = getAgentIdentity(threadId, cwd, itemInfo.role);
+    if (isEventType(type, "item.started")) {
+      pendingItems.set(itemId, itemInfo);
+      emitEvent({
+        agentId: identity.agentId,
+        agentName: identity.agentName,
+        source: "codex-cli",
+        event: "call_start",
+        toolName: itemInfo.toolName,
+        arguments: asRecord(item.arguments) ?? {},
+        timestamp,
+        requestId: `${threadId}-${itemId}-start-${timestamp}`,
+        metadata: {
+          threadId,
+          turnId,
+          itemId,
+          itemType: itemInfo.itemType,
+          cwd: cwd ?? "unknown"
+        }
+      });
+      return;
+    }
+    const existing = pendingItems.get(itemId) ?? itemInfo;
+    pendingItems.delete(itemId);
+    const status = typeof item.status === "string" ? item.status.toLowerCase() : "completed";
+    const itemError = asRecord(item.error)?.message ?? (typeof item.error === "string" ? item.error : void 0);
+    const failed = status.includes("fail") || status.includes("error") || status.includes("declin") || !!itemError;
+    emitEvent({
+      agentId: identity.agentId,
+      agentName: identity.agentName,
+      source: "codex-cli",
+      event: failed ? "call_error" : "call_end",
+      toolName: existing.toolName,
+      timestamp,
+      requestId: `${threadId}-${itemId}-end-${timestamp}`,
+      ...failed ? { error: itemError ?? `Item failed (${status})` } : {},
+      metadata: {
+        threadId,
+        turnId,
+        itemId,
+        itemType: existing.itemType,
+        cwd: cwd ?? "unknown",
+        codexStatus: status
+      }
+    });
+  }
+}
+process.stdin.setEncoding("utf-8");
+var buffer = "";
+process.stdin.on("data", (chunk) => {
+  buffer += chunk;
+  let newlineIndex = buffer.indexOf("\n");
+  while (newlineIndex !== -1) {
+    const line = buffer.slice(0, newlineIndex).trim();
+    buffer = buffer.slice(newlineIndex + 1);
+    if (line) {
+      try {
+        const payload = JSON.parse(line);
+        handlePayload(payload);
+      } catch (err) {
+        log(`Invalid JSONL line: ${err?.message ?? String(err)}`);
+      }
+    }
+    newlineIndex = buffer.indexOf("\n");
+  }
+});
+process.stdin.on("end", () => {
+  const tail = buffer.trim();
+  if (tail) {
+    try {
+      const payload = JSON.parse(tail);
+      handlePayload(payload);
+    } catch (err) {
+      log(`Invalid tail JSON: ${err?.message ?? String(err)}`);
+    }
+  }
+});

package/dist/gemini-cli-hook.cjs

@@ -123,6 +123,70 @@ var ROLE_LABELS = {
   runner: "Runner",
   searcher: "Searcher"
 };
+function extractToolMessage(toolName, toolInput) {
+  const str = (v, max = 80) => typeof v === "string" && v.trim() ? v.trim().slice(0, max) : void 0;
+  switch (toolName) {
+    case "read_file":
+    case "read_many_files":
+      return str(toolInput["path"] ?? toolInput["paths"]) ? `Reading ${str(toolInput["path"] ?? toolInput["paths"])}` : void 0;
+    case "list_directory":
+      return str(toolInput["path"]) ? `Listing ${str(toolInput["path"])}` : void 0;
+    case "write_file":
+      return str(toolInput["path"]) ? `Writing ${str(toolInput["path"])}` : void 0;
+    case "replace":
+      return str(toolInput["path"]) ? `Editing ${str(toolInput["path"])}` : void 0;
+    case "run_shell_command": {
+      const cmd = str(toolInput["command"], 100);
+      return cmd ? `Running: ${cmd}` : void 0;
+    }
+    case "grep_search": {
+      const pat = str(toolInput["pattern"]);
+      const dir = str(toolInput["directory"] ?? toolInput["path"], 40);
+      return pat ? `Searching "${pat}"${dir ? ` in ${dir}` : ""}` : void 0;
+    }
+    case "google_web_search":
+      return str(toolInput["query"]) ? `Web search: ${str(toolInput["query"])}` : void 0;
+    case "web_fetch":
+      return str(toolInput["url"]) ? `Fetching ${str(toolInput["url"])}` : void 0;
+    case "save_memory":
+      return "Saving to memory";
+    case "write_todos":
+      return "Updating task list";
+    case "ask_user": {
+      const q = str(toolInput["question"], 80);
+      return q ? `Asking: ${q}` : void 0;
+    }
+    case "complete_task": {
+      const result = str(toolInput["result"], 80);
+      return result ? `Completing task: ${result}` : void 0;
+    }
+    default:
+      if (toolName.startsWith("mcp_")) {
+        return `Using ${toolName.replace(/^mcp_[^_]+_/, "").replace(/_/g, " ")}`;
+      }
+      return void 0;
+  }
+}
+function extractResultText(response) {
+  if (!response || typeof response !== "object") return void 0;
+  const obj = response;
+  for (const key of ["text", "content", "output", "result", "stdout"]) {
+    if (typeof obj[key] === "string" && obj[key].trim())
+      return obj[key].trim();
+  }
+  const llm = obj.llmContent;
+  if (typeof llm === "string" && llm.trim()) return llm.trim();
+  if (llm && typeof llm === "object") {
+    const llmObj = llm;
+    if (typeof llmObj.text === "string" && llmObj.text.trim())
+      return llmObj.text.trim();
+    if (Array.isArray(llmObj.parts)) {
+      const parts = llmObj.parts.map((p) => typeof p === "string" ? p : p?.text).filter((t) => typeof t === "string" && t.trim());
+      if (parts.length > 0) return parts.join("\n").trim() || void 0;
+    }
+  }
+  return void 0;
+}
 function getRole(toolName) {
   if (TOOL_ROLES[toolName]) return TOOL_ROLES[toolName];
   if (toolName.startsWith("mcp_")) {
@@ -220,6 +284,7 @@ process.stdin.on("end", () => {
     } else {
       eventType = "call_start";
     }
+    const resultText = isAfter ? extractResultText(tool_response) : void 0;
     const event = {
       agentId,
       agentName,
@@ -230,6 +295,9 @@ process.stdin.on("end", () => {
       timestamp: timestamp ? new Date(timestamp).getTime() : Date.now(),
       requestId: `${session_id}-${tool_name}-${Date.now()}`,
       ...hasError ? { error: String(tool_response.error) } : {},
+      // On BeforeTool: attach context hint; on AfterTool: attach tool result
+      ...!isAfter && tool_input ? { message: extractToolMessage(tool_name, tool_input) } : {},
+      ...isAfter && resultText ? { message: resultText } : {},
       metadata: {
         cwd: cwd ?? "unknown",
         role,

package/dist/index.html

@@ -4,15 +4,15 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>AgentMomo — MCP Activity Visualizer</title>
+    <title>AgentMOMO— MCP Activity Visualizer</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link
       href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400..900&display=swap"
       rel="stylesheet"
     />
-    <script type="module" crossorigin src="/assets/index-BwEFhEay.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CS8oLlw3.css">
+    <script type="module" crossorigin src="/assets/index-BQyAbSge.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BjOLTppo.css">
   </head>
   <body>
     <div id="root"></div>