@integrity-labs/agt-cli 0.28.288 → 0.28.290

package/dist/mcp/remote-oauth-proxy.js

@@ -43,6 +43,46 @@ function buildEnableToolsetRequest(toolset) {
     params: { name: "enable_toolset", arguments: { name: toolset } }
   });
 }
+function buildToolsListRequest() {
+  return JSON.stringify({ jsonrpc: "2.0", id: "agt-union-list", method: "tools/list", params: {} });
+}
+function toolName(t) {
+  return t && typeof t === "object" && typeof t.name === "string" ? t.name : "";
+}
+function extractToolsArray(message) {
+  try {
+    const tools = JSON.parse(message)?.result?.tools;
+    return Array.isArray(tools) ? tools : [];
+  } catch {
+    return [];
+  }
+}
+function parseEnableToolsetResponse(message) {
+  let payload;
+  try {
+    const obj = JSON.parse(message);
+    payload = obj?.result ?? obj;
+    const content = payload?.content;
+    if (Array.isArray(content)) {
+      const textPart = content.find(
+        (c) => c && typeof c === "object" && c.type === "text" && typeof c.text === "string"
+      );
+      if (textPart?.text) {
+        try {
+          payload = JSON.parse(textPart.text);
+        } catch {
+        }
+      }
+    }
+  } catch {
+    return { activated: null, newlyAvailable: [] };
+  }
+  const p = payload && typeof payload === "object" ? payload : null;
+  const activated = p && typeof p.activated === "string" ? p.activated : null;
+  const nat = p && Array.isArray(p.newly_available_tools) ? p.newly_available_tools : [];
+  const newlyAvailable = nat.map((t) => typeof t === "string" ? t : toolName(t)).filter((n) => typeof n === "string" && n.length > 0);
+  return { activated, newlyAvailable };
+}
 function parseToolAllowlist(raw) {
   const out = /* @__PURE__ */ new Set();
   for (const part of (raw || "").split(",")) {
@@ -126,53 +166,85 @@ function extractJsonRpcMessages(contentType, body) {
   }
   return out;
 }
-var preEnabledOnce = null;
-function ensurePreEnabled(token) {
-  if (preEnabledOnce) return preEnabledOnce;
-  preEnabledOnce = Promise.allSettled(
-    preEnableToolsets.map(async (name) => {
-      const res = await fetch(remoteUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json, text/event-stream",
-          Authorization: `Bearer ${token}`
-        },
-        body: buildEnableToolsetRequest(name),
-        signal: AbortSignal.timeout(REMOTE_FETCH_TIMEOUT_MS)
-      });
-      const body = await res.text().catch(() => "");
-      if (!res.ok) {
-        throw new Error(`HTTP ${res.status}${body ? ` (${body.slice(0, 200).replace(/\s+/g, " ").trim()})` : ""}`);
-      }
-      let rpcError;
+async function postRpc(token, body) {
+  const res = await fetch(remoteUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${token}`
+    },
+    body,
+    signal: AbortSignal.timeout(REMOTE_FETCH_TIMEOUT_MS)
+  });
+  const text = await res.text().catch(() => "");
+  return { ok: res.ok, status: res.status, ct: res.headers.get("content-type") ?? "", text };
+}
+var unionOnce = null;
+var unionToolByName = /* @__PURE__ */ new Map();
+var toolGroupByName = /* @__PURE__ */ new Map();
+function mergeToolsListInto(ct, text) {
+  for (const m of extractJsonRpcMessages(ct, text)) {
+    for (const t of extractToolsArray(m)) {
+      const n = toolName(t);
+      if (n) unionToolByName.set(n, t);
+    }
+  }
+}
+function ensureUnionManifest(token) {
+  if (unionOnce) return unionOnce;
+  unionOnce = (async () => {
+    try {
+      const seed = await postRpc(token, buildToolsListRequest());
+      mergeToolsListInto(seed.ct, seed.text);
+    } catch (err) {
+      logErr(`union: seed tools/list failed: ${err.message}`);
+    }
+    for (const group of preEnableToolsets) {
       try {
-        rpcError = JSON.parse(body)?.error?.message;
-      } catch {
-      }
-      if (rpcError) throw new Error(rpcError);
-      return name;
-    })
-  ).then((results) => {
-    results.forEach((r, i) => {
-      const name = preEnableToolsets[i];
-      if (r.status === "fulfilled") {
-        logErr(`pre-enabled toolset "${name}"`);
-      } else {
-        logErr(`pre-enable toolset "${name}" failed: ${r.reason.message}`);
+        const en = await postRpc(token, buildEnableToolsetRequest(group));
+        if (!en.ok) {
+          logErr(`union: enable "${group}" HTTP ${en.status}`);
+          continue;
+        }
+        for (const m of extractJsonRpcMessages(en.ct, en.text)) {
+          for (const nm of parseEnableToolsetResponse(m).newlyAvailable) toolGroupByName.set(nm, group);
+        }
+        for (const nm of parseEnableToolsetResponse(en.text).newlyAvailable) toolGroupByName.set(nm, group);
+        const li = await postRpc(token, buildToolsListRequest());
+        mergeToolsListInto(li.ct, li.text);
+        logErr(`union: enabled "${group}" (union now ${unionToolByName.size} tools, ${toolGroupByName.size} mapped)`);
+      } catch (err) {
+        logErr(`union: enable "${group}" failed: ${err.message}`);
       }
-    });
-  });
-  return preEnabledOnce;
+    }
+  })();
+  return unionOnce;
 }
-async function forward(line, id, isNotification, method) {
+async function forward(line, id, isNotification, method, params) {
   const token = readCurrentToken(tokenFile, tokenVar);
   if (!token) {
     logErr(`no token in ${tokenFile} (var ${tokenVar})`);
     return isNotification ? [] : [jsonRpcError(id, -32e3, `${label}: no current access token available (reconnect the integration)`)];
   }
   if (method === "tools/list" && preEnableToolsets.length > 0) {
-    await ensurePreEnabled(token);
+    await ensureUnionManifest(token);
+    let tools = [...unionToolByName.values()];
+    if (toolAllowlist.size > 0) tools = tools.filter((t) => toolAllowlist.has(toolName(t)));
+    return [JSON.stringify({ jsonrpc: "2.0", id: id ?? null, result: { tools } })];
+  }
+  if (method === "tools/call" && preEnableToolsets.length > 0) {
+    await ensureUnionManifest(token);
+    const callName = params && typeof params === "object" && typeof params.name === "string" ? params.name : "";
+    const group = callName ? toolGroupByName.get(callName) : void 0;
+    if (group) {
+      try {
+        const en = await postRpc(token, buildEnableToolsetRequest(group));
+        if (!en.ok) logErr(`per-call enable "${group}" for "${callName}" HTTP ${en.status}`);
+      } catch (err) {
+        logErr(`per-call enable "${group}" for "${callName}" failed: ${err.message}`);
+      }
+    }
   }
   let res;
   try {
@@ -265,7 +337,7 @@ async function main() {
         return;
       }
     }
-    const task = forward(text, id, isNotification, parsed.method).then(writeReplies).catch((err) => {
+    const task = forward(text, id, isNotification, parsed.method, parsed.params).then(writeReplies).catch((err) => {
       logErr(`handler error: ${err.message}`);
     });
     inflight.add(task);
@@ -289,11 +361,15 @@ if (invokedDirectly) {
 }
 export {
   buildEnableToolsetRequest,
+  buildToolsListRequest,
   extractJsonRpcMessages,
+  extractToolsArray,
   filterToolsListMessage,
   isToolCallBlocked,
   main,
+  parseEnableToolsetResponse,
   parsePreEnableToolsets,
   parseToolAllowlist,
-  readCurrentToken
+  readCurrentToken,
+  toolName
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.28.288",
+  "version": "0.28.290",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {