@integrity-labs/agt-cli 0.27.144 → 0.27.146

package/dist/mcp/slack-channel.js

@@ -14305,6 +14305,45 @@ function readDeclineCooldownMs(envVarName, defaultSeconds = 1800) {
   return parsed * 1e3;
 }
 
+// src/inbound-access.ts
+function decideInboundAccess(input) {
+  if (!input.content.forward) {
+    return { kind: "drop", reason: `content:${input.content.reason}` };
+  }
+  if (input.isSelf) {
+    return { kind: "drop", reason: "self" };
+  }
+  if (input.orgBoundary && !input.orgBoundary.forward) {
+    return { kind: "drop", reason: "org_boundary" };
+  }
+  if (input.senderPolicy && !input.senderPolicy.forward) {
+    const reason = input.senderPolicy.reason;
+    const declineWorthy = input.sameOrg && reason !== "internal_only";
+    return {
+      kind: "drop",
+      reason: `sender_policy:${reason}`,
+      decline: declineWorthy ? politeDeclineCopy(reason) : void 0
+    };
+  }
+  if (input.command && !input.isBot) {
+    return {
+      kind: "command",
+      command: input.command.command,
+      authorized: input.command.authorized
+    };
+  }
+  if (input.isBot) {
+    const peer = input.peer;
+    if (!peer || peer.kind === "self") {
+      return { kind: "drop", reason: peer?.kind === "self" ? "self" : "peer:unclassified" };
+    }
+    if (peer.kind === "drop") {
+      return { kind: "drop", reason: `peer:${peer.reason ?? "unspecified"}` };
+    }
+  }
+  return { kind: "admit" };
+}
+
 // src/ack-reaction.ts
 import { readdirSync, readFileSync } from "fs";
 import { join } from "path";
@@ -19069,132 +19108,134 @@ async function connectSocketMode() {
       const evt = msg.payload.event;
       if (evt.user === botUserId) return;
       if (evt.type !== "app_mention" && evt.type !== "message") return;
+      const isBot = Boolean(evt.bot_id);
       const filterDecision = decideSlackMessageForward(evt);
-      if (!filterDecision.forward) {
-        process.stderr.write(`slack-channel: dropped message event (reason=${filterDecision.reason}, subtype=${evt.subtype ?? "none"}, ts=${evt.ts ?? "n/a"})
-`);
-        return;
-      }
       const senderPolicyDecision = decideSenderPolicyForward(evt, SLACK_SENDER_POLICY);
-      if (!senderPolicyDecision.forward) {
-        const subReason = classifySlackPolicyBlock(evt, SLACK_SENDER_POLICY);
-        process.stderr.write(`slack-channel: dropped message event (reason=sender_policy, sub=${subReason}, mode=${SLACK_SENDER_POLICY.mode}, ts=${evt.ts ?? "n/a"})
-`);
-        await maybeSendSenderPolicyDecline({
-          channel: evt.channel,
-          senderId: evt.user,
-          // CR on PR #1623: top-level posts (DMs, channel root messages)
-          // arrive with no `thread_ts` and MUST decline inline, not in a
-          // new thread off the inbound message. The `?? evt.ts` fallback
-          // forced every root message into a thread reply — exactly the
-          // case the helper's "omit thread_ts when undefined" branch was
-          // meant to handle. Pass through as-is: in-thread for thread
-          // replies (thread_ts present), inline for everything else.
-          threadTs: evt.thread_ts,
-          subReason
-        }).catch((err) => {
-          process.stderr.write(
-            `slack-channel(${AGENT_CODE_NAME}): decline reply failed: ${err.message}
-`
-          );
-        });
-        return;
-      }
-      recordActivity("inbound");
-      const isDirectMessage = evt.channel?.startsWith("D");
-      const isThreadReply = !!evt.thread_ts && evt.thread_ts !== evt.ts;
-      const trackTs = evt.thread_ts ?? evt.ts ?? "";
-      const threadKey = buildThreadKey(evt.channel, trackTs);
+      const policyBlockReason = senderPolicyDecision.forward ? void 0 : classifySlackPolicyBlock(evt, SLACK_SENDER_POLICY);
+      const peerClassification = isBot ? classifyPeerMessage(
+        {
+          text: evt.text,
+          channel: evt.channel ?? "",
+          channel_type: evt.channel_type,
+          user: evt.user,
+          bot_id: evt.bot_id,
+          thread_ts: evt.thread_ts,
+          parent_user_id: evt.parent_user_id
+        },
+        SLACK_PEER_CLASSIFIER_CONFIG,
+        { bot_user_id: botUserId }
+      ) : void 0;
       const rawText = evt.text ?? "";
       const strippedText = rawText.replace(/^\s*<@[^>]+>\s*/, "").trim();
       const restartSuffixed = agentSlashCommand("/restart");
+      const helpSuffixed = agentSlashCommand("/help");
       const isRestartCommand = strippedText === "/restart" || strippedText.startsWith("/restart ") || strippedText === restartSuffixed || strippedText.startsWith(`${restartSuffixed} `);
-      const isHelpCommand = strippedText === "/help" || strippedText.startsWith("/help ");
-      if (isHelpCommand) {
-        await handleHelpCommand({
-          channel: evt.channel ?? "",
-          threadTs: evt.thread_ts,
-          ts: evt.ts ?? ""
-        });
+      const isHelpCommand = strippedText === "/help" || strippedText.startsWith("/help ") || strippedText === helpSuffixed || strippedText.startsWith(`${helpSuffixed} `);
+      const command = isBot ? void 0 : isHelpCommand ? { command: "help", authorized: true } : isRestartCommand ? { command: "restart", authorized: isRestartSenderAllowed(getEffectiveAllowedUsers(), evt.user) } : void 0;
+      const slackHomeTeamId = process.env.SLACK_HOME_TEAM_ID;
+      const sameOrg = !!slackHomeTeamId && evt.team === slackHomeTeamId;
+      const access = decideInboundAccess({
+        content: filterDecision.forward ? { forward: true } : { forward: false, reason: filterDecision.reason },
+        // The agent's own user-echo was already skipped above; peer 'self'
+        // covers the bot-id self case inside the composer.
+        isSelf: false,
+        isBot,
+        peer: peerClassification ? {
+          kind: peerClassification.kind,
+          reason: peerClassification.kind === "drop" ? peerClassification.reason : void 0
+        } : void 0,
+        senderPolicy: senderPolicyDecision.forward ? { forward: true } : { forward: false, reason: policyBlockReason },
+        command,
+        sameOrg
+      });
+      const passedIdentity = access.kind !== "drop" || access.reason.startsWith("peer:");
+      if (passedIdentity) recordActivity("inbound");
+      if (access.kind === "drop") {
+        const channelHash = createHash("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
+        process.stderr.write(
+          `slack-channel: inbound drop reason=${access.reason} channel=${channelHash} ts=${redactSlackId(evt.ts)}
+`
+        );
+        if (access.decline !== void 0 && policyBlockReason) {
+          await maybeSendSenderPolicyDecline({
+            channel: evt.channel,
+            senderId: evt.user,
+            threadTs: evt.thread_ts,
+            subReason: policyBlockReason
+          }).catch((err) => {
+            process.stderr.write(
+              `slack-channel(${AGENT_CODE_NAME}): decline reply failed: ${err.message}
+`
+            );
+          });
+        }
+        if (access.reason === "peer:cross_team_grant_missing") {
+          crossTeamPeerAuditClient?.emit({
+            event_type: "slack.peer.drop.cross_team_grant_missing",
+            peer_agent_id: null,
+            gate_path: null,
+            grant_id: null,
+            chat_id: evt.channel ?? null,
+            message_id: evt.ts ?? null
+          });
+        }
         return;
       }
-      if (isRestartCommand) {
-        const senderAllowed = isRestartSenderAllowed(getEffectiveAllowedUsers(), evt.user);
-        if (!senderAllowed) {
-          await denyUnauthorizedRestart({
+      if (access.kind === "command") {
+        if (access.command === "help") {
+          await handleHelpCommand({
             channel: evt.channel ?? "",
-            threadTs: evt.thread_ts
+            threadTs: evt.thread_ts,
+            ts: evt.ts ?? ""
           });
           return;
         }
-        const resolvedName = await resolveUserName(evt.user);
-        const requesterName = resolvedName && resolvedName !== evt.user ? resolvedName : void 0;
-        await handleRestartCommand({
-          channel: evt.channel ?? "",
-          // Only carry thread_ts when the originating message was already
-          // threaded; a top-level command acks in-channel rather than
-          // synthesising a brand-new thread (CodeRabbit feedback).
-          threadTs: evt.thread_ts,
-          ts: evt.ts ?? "",
-          requesterName
-        });
-        return;
-      }
-      if (evt.bot_id) {
-        const peerMsg = {
-          text: evt.text,
-          channel: evt.channel ?? "",
-          channel_type: evt.channel_type,
-          user: evt.user,
-          bot_id: evt.bot_id,
-          thread_ts: evt.thread_ts,
-          parent_user_id: evt.parent_user_id
-        };
-        const decision = classifyPeerMessage(
-          peerMsg,
-          SLACK_PEER_CLASSIFIER_CONFIG,
-          { bot_user_id: botUserId }
-        );
-        if (decision.kind === "self") return;
-        if (decision.kind === "drop") {
-          const channelHash = createHash("sha256").update(evt.channel ?? "").digest("hex").slice(0, 8);
-          process.stderr.write(
-            `slack-channel: peer drop reason=${decision.reason} channel=${channelHash}
-`
-          );
-          if (decision.reason === "cross_team_grant_missing") {
-            crossTeamPeerAuditClient?.emit({
-              event_type: "slack.peer.drop.cross_team_grant_missing",
-              peer_agent_id: null,
-              gate_path: null,
-              grant_id: null,
-              chat_id: evt.channel ?? null,
-              message_id: evt.ts ?? null
+        if (access.command === "restart") {
+          if (!access.authorized) {
+            await denyUnauthorizedRestart({
+              channel: evt.channel ?? "",
+              threadTs: evt.thread_ts
             });
+            return;
           }
+          const resolvedName = await resolveUserName(evt.user);
+          const requesterName = resolvedName && resolvedName !== evt.user ? resolvedName : void 0;
+          await handleRestartCommand({
+            channel: evt.channel ?? "",
+            // Only carry thread_ts when the originating message was already
+            // threaded; a top-level command acks in-channel.
+            threadTs: evt.thread_ts,
+            ts: evt.ts ?? "",
+            requesterName
+          });
           return;
         }
-        if (decision.kind === "peer-ingress") {
-          const peerGate = decision.peer.gate_path;
-          if (peerGate === "intra_org_unrestricted") {
-            crossTeamPeerAuditClient?.emit({
-              event_type: "slack.peer.ingress.cross_team",
-              peer_agent_id: decision.peer.agent_id || null,
-              gate_path: peerGate,
-              grant_id: null,
-              chat_id: evt.channel ?? null,
-              message_id: evt.ts ?? null
-            });
-          } else if (typeof peerGate === "string" && peerGate.startsWith("grant:")) {
-            crossTeamPeerAuditClient?.emit({
-              event_type: "slack.peer.ingress.cross_team",
-              peer_agent_id: decision.peer.agent_id || null,
-              gate_path: peerGate,
-              grant_id: peerGate.slice("grant:".length),
-              chat_id: evt.channel ?? null,
-              message_id: evt.ts ?? null
-            });
-          }
+        return;
+      }
+      const isDirectMessage = evt.channel?.startsWith("D");
+      const isThreadReply = !!evt.thread_ts && evt.thread_ts !== evt.ts;
+      const trackTs = evt.thread_ts ?? evt.ts ?? "";
+      const threadKey = buildThreadKey(evt.channel, trackTs);
+      if (isBot && peerClassification?.kind === "peer-ingress") {
+        const peerGate = peerClassification.peer.gate_path;
+        if (peerGate === "intra_org_unrestricted") {
+          crossTeamPeerAuditClient?.emit({
+            event_type: "slack.peer.ingress.cross_team",
+            peer_agent_id: peerClassification.peer.agent_id || null,
+            gate_path: peerGate,
+            grant_id: null,
+            chat_id: evt.channel ?? null,
+            message_id: evt.ts ?? null
+          });
+        } else if (typeof peerGate === "string" && peerGate.startsWith("grant:")) {
+          crossTeamPeerAuditClient?.emit({
+            event_type: "slack.peer.ingress.cross_team",
+            peer_agent_id: peerClassification.peer.agent_id || null,
+            gate_path: peerGate,
+            grant_id: peerGate.slice("grant:".length),
+            chat_id: evt.channel ?? null,
+            message_id: evt.ts ?? null
+          });
         }
       }
       if (evt.type === "app_mention") {

package/dist/mcp/teams-channel.js

@@ -14430,6 +14430,45 @@ function readDeclineCooldownMs(envVarName, defaultSeconds = 1800) {
   return parsed * 1e3;
 }
 
+// src/inbound-access.ts
+function decideInboundAccess(input) {
+  if (!input.content.forward) {
+    return { kind: "drop", reason: `content:${input.content.reason}` };
+  }
+  if (input.isSelf) {
+    return { kind: "drop", reason: "self" };
+  }
+  if (input.orgBoundary && !input.orgBoundary.forward) {
+    return { kind: "drop", reason: "org_boundary" };
+  }
+  if (input.senderPolicy && !input.senderPolicy.forward) {
+    const reason = input.senderPolicy.reason;
+    const declineWorthy = input.sameOrg && reason !== "internal_only";
+    return {
+      kind: "drop",
+      reason: `sender_policy:${reason}`,
+      decline: declineWorthy ? politeDeclineCopy(reason) : void 0
+    };
+  }
+  if (input.command && !input.isBot) {
+    return {
+      kind: "command",
+      command: input.command.command,
+      authorized: input.command.authorized
+    };
+  }
+  if (input.isBot) {
+    const peer = input.peer;
+    if (!peer || peer.kind === "self") {
+      return { kind: "drop", reason: peer?.kind === "self" ? "self" : "peer:unclassified" };
+    }
+    if (peer.kind === "drop") {
+      return { kind: "drop", reason: `peer:${peer.reason ?? "unspecified"}` };
+    }
+  }
+  return { kind: "admit" };
+}
+
 // src/teams-peer-classifier.ts
 function classifyTeamsPeerMessage(input) {
   const { activity, config: config2 } = input;
@@ -14901,34 +14940,8 @@ async function processPendingFile(filename) {
   } catch {
     return;
   }
-  if (!decision.forward) {
-    process.stderr.write(
-      `teams-channel: dropped activity id=${activity.id ?? "?"} reason=${decision.reason}
-`
-    );
-    return;
-  }
   const senderPolicyDecision = decideSenderPolicyForwardTeams(activity, MSTEAMS_SENDER_POLICY);
-  if (!senderPolicyDecision.forward) {
-    const subReason = classifyTeamsPolicyBlock(activity, MSTEAMS_SENDER_POLICY);
-    process.stderr.write(
-      `teams-channel: dropped activity id=${activity.id ?? "?"} reason=sender_policy sub=${subReason} mode=${MSTEAMS_SENDER_POLICY.mode}
-`
-    );
-    await maybeSendTeamsSenderPolicyDecline({
-      serviceUrl: activity.serviceUrl,
-      conversationId: activity.conversation?.id,
-      replyToId: activity.id,
-      senderId: activity.from?.aadObjectId ?? activity.from?.id,
-      subReason
-    }).catch((err) => {
-      process.stderr.write(
-        `teams-channel: decline reply failed: ${err.message}
-`
-      );
-    });
-    return;
-  }
+  const policyBlockReason = senderPolicyDecision.forward ? void 0 : classifyTeamsPolicyBlock(activity, MSTEAMS_SENDER_POLICY);
   const peerDecision = classifyTeamsPeerMessage({
     activity,
     config: {
@@ -14937,11 +14950,42 @@ async function processPendingFile(filename) {
       mode: PEER_AGENT_MODE
     }
   });
-  if (peerDecision.classification === "peer_agent" && peerDecision.action === "drop") {
+  const peerKind = peerDecision.classification === "peer_agent" && peerDecision.action === "drop" ? "drop" : peerDecision.classification === "peer_agent" ? "peer-ingress" : "human";
+  const senderTenantId = activity.channelData?.tenant?.id ?? activity.conversation?.tenantId;
+  const homeTenantId = process.env.MSTEAMS_HOME_TENANT_ID;
+  const sameOrg = !!homeTenantId && homeTenantId !== "common" && senderTenantId === homeTenantId;
+  const access = decideInboundAccess({
+    content: decision.forward ? { forward: true } : { forward: false, reason: decision.reason },
+    isSelf: false,
+    // self-drop handled inside decideTeamsActivityForward
+    isBot: true,
+    // the peer classifier ran for every activity; 'human' falls through
+    peer: {
+      kind: peerKind,
+      reason: "reason" in peerDecision ? peerDecision.reason : void 0
+    },
+    senderPolicy: senderPolicyDecision.forward ? { forward: true } : { forward: false, reason: policyBlockReason },
+    sameOrg
+  });
+  if (access.kind === "drop") {
     process.stderr.write(
-      `teams-channel: dropped peer activity id=${activity.id ?? "?"} reason=${peerDecision.reason}
+      `teams-channel: inbound drop id=${activity.id ?? "?"} reason=${access.reason}
 `
     );
+    if (access.decline !== void 0 && policyBlockReason) {
+      await maybeSendTeamsSenderPolicyDecline({
+        serviceUrl: activity.serviceUrl,
+        conversationId: activity.conversation?.id,
+        replyToId: activity.id,
+        senderId: activity.from?.aadObjectId ?? activity.from?.id,
+        subReason: policyBlockReason
+      }).catch((err) => {
+        process.stderr.write(
+          `teams-channel: decline reply failed: ${err.message}
+`
+        );
+      });
+    }
     return;
   }
   if (activity.serviceUrl && activity.conversation?.id) {