@patimweb/pi-teams 1.12.0 → 1.14.0

package/docs/listen-mode.md

@@ -46,7 +46,7 @@ never sees.
 | `autoStart` | `false` | whether a session with a UI may start the watcher without being asked |
 | `intervalSeconds` | `60` | seconds between polls (minimum 15) |
 | `chats` | `[]` | **where** pi listens: glob patterns matched against topic, label, chat ID and participant names. Empty means every recent chat. |
-| `from` | `[]` | **who** pi listens to: glob patterns matched against display name, UPN and e-mail. Empty means any sender. |
+| `from` | `[]` | **who** pi listens to: glob patterns matched against display name, UPN and e-mail — so `*@contoso.com` covers a whole domain. Graph sends a sender without address; pi fills it in from the chat's member list or the directory. Empty means any sender. |
 | `mentionOnly` | `false` | whether a message has to address you: `true`/`false`, or `{ default, chats, people }` for overrides. See [below](#who-has-to-address-pi). |
 | `cooldownSeconds` | `300` | stay quiet in a chat after waking pi for it |
 | `maxTriggersPerHour` | `10` | hard cap on wakes per hour |
@@ -186,3 +186,11 @@ and renews it every 5 minutes for 15 minutes at a time. You show as
 **Available**, or as whatever you picked with `teams_set_presence`. When the
 watcher stops, pi clears the session and you drop back to Offline straight away
 (at the latest 15 minutes after pi was killed).
+
+## "Seen" as soon as pi picks a message up
+
+When a message wakes pi, the chat is marked read right away — before the answer
+is written. With read receipts on in the tenant, the sender sees the "seen" eye
+under their message and knows a reply is coming. A real typing indicator
+("…") is not possible: Microsoft Graph has no typing API for user accounts,
+only the Bot Framework has one for bots.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patimweb/pi-teams",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "Microsoft Teams integration for pi coding agent — acts fully as the signed-in user across multiple accounts and tenants: chats, channels, meetings, presence, with configurable guardrails",
   "keywords": [
     "pi-package",

package/src/extension/index.ts

@@ -37,6 +37,7 @@ import {
 	type WatchLoop,
 } from "../watch/loop.ts";
 import { composeWatchPrompt } from "../watch/prompt.ts";
+import { setChatReadState } from "../graph/chats.ts";
 import { clearWakeTarget, pinViolation, pinWakeTarget } from "../watch/pin.ts";
 import { readWatchCursor, writeWatchCursor } from "../watch/cursor.ts";
 
@@ -225,6 +226,13 @@ export default function (pi: ExtensionAPI) {
 				// answer the chat that woke pi, and the message it is about to read
 				// was written by somebody else.
 				pinWakeTarget(event.chat.id, event.chat.label);
+				// Mark the chat read the moment pi picks it up: with read receipts on,
+				// the sender sees the "seen" eye right away — the closest thing to a
+				// typing indicator Graph offers (there is no typing API for users).
+				// Fire-and-forget: a failed receipt must not hold up the answer.
+				if (event.me?.id) {
+					void setChatReadState(conn, event.chat.id, event.me, true).catch(() => undefined);
+				}
 				pi.sendUserMessage(composeWatchPrompt(event, event.me), { deliverAs: "followUp" });
 			},
 			onTick: (status) => {

package/src/graph/mappers.ts

@@ -52,7 +52,8 @@ export function mapPerson(raw: Raw | undefined): PersonRef | undefined {
 	const name = identity.displayName ?? identity.userPrincipalName ?? identity.email;
 	if (!name && !identity.id) return undefined;
 	return {
-		id: identity.id ?? undefined,
+		// A chat member's `id` is the *membership* id; the person is `userId`.
+		id: identity.userId ?? identity.id ?? undefined,
 		displayName: name ?? "(unknown)",
 		upn: identity.userPrincipalName ?? undefined,
 		mail: identity.email ?? identity.mail ?? undefined,

package/src/graph/me.ts

@@ -20,6 +20,26 @@ export async function getMe(conn: TeamsConnection, signal?: AbortSignal): Promis
 	return { ...user, tenantId: conn.tenantId };
 }
 
+/**
+ * UPN and mail of one user, by object id.
+ *
+ * A chat message's sender carries only id and display name, so a listen rule
+ * like `*@contoso.com` has nothing to match against without this lookup.
+ */
+export async function getUserAddresses(
+	conn: TeamsConnection,
+	userId: string,
+	signal?: AbortSignal,
+): Promise<{ upn?: string; mail?: string }> {
+	const raw = await graphRequest<Record<string, string | null | undefined>>(
+		conn,
+		"GET",
+		`/users/${encodeURIComponent(userId)}`,
+		{ query: { $select: "userPrincipalName,mail" }, signal },
+	);
+	return { upn: raw?.userPrincipalName ?? undefined, mail: raw?.mail ?? undefined };
+}
+
 /**
  * Find people by name, UPN or e-mail.
  *

package/src/watch/index.ts

@@ -237,6 +237,34 @@ export function isWatchedChat(chat: ChatSummary, watch: ResolvedWatchConfig): bo
 // Who pi listens to
 // ---------------------------------------------------------------------------
 
+/**
+ * The sender of a message, with the addresses Graph left out filled in.
+ *
+ * `chatMessage.from.user` carries only id and display name — no UPN, no mail —
+ * so a listen rule like `*@contoso.com` could never match a sender. The chat's
+ * member list does carry the mail address, so the sender is looked up there
+ * first (by user id, else by display name).
+ */
+export function withSenderAddresses(message: MessageSummary, chat: ChatSummary): MessageSummary {
+	const sender = message.from;
+	if (!sender || (sender.upn && sender.mail)) return message;
+
+	const member =
+		(sender.id ? chat.members.find((m) => m.id === sender.id) : undefined) ??
+		chat.members.find((m) => m.displayName === sender.displayName);
+	if (!member || (!member.upn && !member.mail)) return message;
+
+	return {
+		...message,
+		from: { ...sender, upn: sender.upn ?? member.upn, mail: sender.mail ?? member.mail },
+	};
+}
+
+/** Does the sender carry an address a rule could match on? */
+export function senderHasAddress(message: MessageSummary): boolean {
+	return !!(message.from?.upn || message.from?.mail);
+}
+
 /**
  * Does the sender fall inside the configured listen list?
  *

package/src/watch/loop.ts

@@ -37,13 +37,16 @@ import {
 	noteWake,
 	openMessages,
 	pruneState,
+	senderHasAddress,
 	settleChat,
 	shouldWake,
 	waitingCount,
 	wakesThisHour,
 	WATCH_MESSAGE_WINDOW,
+	withSenderAddresses,
 	type WatchState,
 } from "./index.ts";
+import { getUserAddresses } from "../graph/me.ts";
 
 // ---------------------------------------------------------------------------
 // Events and status
@@ -145,6 +148,12 @@ export interface WatchTickDeps {
 	 * this chat": without it a restart replays what was already answered.
 	 */
 	persistCursor?: (seen: ReadonlyMap<string, string>) => void;
+	/**
+	 * UPN and mail of a user by id, for senders the chat's member list could not
+	 * fill in. Without an address, a listen rule like `*@contoso.com` cannot
+	 * match. Optional; a failure leaves the sender as it was.
+	 */
+	lookupAddresses?: (userId: string) => Promise<{ upn?: string; mail?: string }>;
 }
 
 export interface WatchTickResult {
@@ -159,6 +168,13 @@ export interface WatchTickResult {
 	wakes: WatchEvent[];
 }
 
+function definedOnly(value: { upn?: string; mail?: string }): { upn?: string; mail?: string } {
+	const out: { upn?: string; mail?: string } = {};
+	if (value.upn) out.upn = value.upn;
+	if (value.mail) out.mail = value.mail;
+	return out;
+}
+
 /**
  * Advance the watcher by one tick.
  *
@@ -237,12 +253,24 @@ export async function runWatchTick(
 
 		noteSuccess(state, chat.id);
 
-		const message = messages.find((entry) => !entry.deletedDateTime) ?? messages[0];
-		if (!message) {
+		const newest = messages.find((entry) => !entry.deletedDateTime) ?? messages[0];
+		if (!newest) {
 			settleChat(state, chat.id, marker);
 			continue;
 		}
 
+		// Graph sends the sender without UPN or mail; fill them in so address
+		// rules (`*@contoso.com`) in `from` and `mentionOnly.people` can match.
+		let message = withSenderAddresses(newest, chat);
+		if (!senderHasAddress(message) && message.from?.id && deps.lookupAddresses) {
+			try {
+				const found = await deps.lookupAddresses(message.from.id);
+				message = { ...message, from: { ...message.from, ...definedOnly(found) } };
+			} catch {
+				/* no address: the rule is matched on name and id alone, as before */
+			}
+		}
+
 		const decision = shouldWake(chat, message, me, watch, state, now);
 		if (!decision.wake) {
 			if (decision.retryAfterMs !== undefined) {
@@ -371,6 +399,18 @@ export function startWatchLoop(options: WatchLoopOptions): WatchLoop {
 	 */
 	let me: SignedInUser | undefined;
 	let failureCount = 0;
+	/** Sender addresses by user id — people rarely change their UPN mid-session. */
+	const addressCache = new Map<string, Promise<{ upn?: string; mail?: string }>>();
+	const lookupAddresses = (userId: string) => {
+		let hit = addressCache.get(userId);
+		if (!hit) {
+			hit = getUserAddresses(connection, userId);
+			// A failed lookup is retried next time instead of being cached.
+			hit.catch(() => addressCache.delete(userId));
+			addressCache.set(userId, hit);
+		}
+		return hit;
+	};
 	const presence =
 		options.presence === undefined
 			? presenceKeeperFor(connection, options.onError)
@@ -416,6 +456,7 @@ export function startWatchLoop(options: WatchLoopOptions): WatchLoop {
 					now: () => Date.now(),
 					allowed: (chat) => hasAccess(connection, "read", "chats", chatCandidates(chat)),
 					persistCursor: options.persistCursor,
+					lookupAddresses,
 				},
 				state,
 				watch,