@patimweb/pi-teams 1.7.1 → 1.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patimweb/pi-teams",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "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

@@ -16,7 +16,13 @@ import {
 	tryResolveConnection,
 	type TeamsConnection,
 } from "../config/index.ts";
-import { buildConnectionCard, buildConnectionLabel, formatStatusText, type ConnectionCard } from "../status.ts";
+import {
+	buildConnectionCard,
+	buildConnectionLabel,
+	buildStartupNotice,
+	formatStatusText,
+	type ConnectionCard,
+} from "../status.ts";
 import {
 	blockReason,
 	formatMutationSummary,
@@ -416,10 +422,8 @@ export default function (pi: ExtensionAPI) {
 				"warning",
 			);
 		} else {
-			ctx.ui.notify(
-				`@patimweb/pi-teams loaded (${card.account}${card.user ? ` as ${card.user}` : ""}, safety: ${card.safetyLevel})`,
-				"info",
-			);
+			const notice = buildStartupNotice(card, connection.watch);
+			ctx.ui.notify(notice.message, notice.level);
 		}
 
 		// Survives /reload, so the transcript keeps saying who pi is acting as.

package/src/graph/mappers.ts

@@ -23,7 +23,7 @@ import type {
 	SignedInUser,
 	TeamSummary,
 } from "../types.ts";
-import { imageUrlsInHtml } from "../utils/attachments.ts";
+import { collectStrings, imageUrlsInHtml } from "../utils/attachments.ts";
 import { htmlToText } from "../utils/formatting.ts";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -227,9 +227,31 @@ function mapAttachments(raw: Raw): MessageAttachment[] {
  * `htmlToText` turns every `<img>` into `[image: alt]`, which is right for a
  * reader that only wants prose and wrong for one that could fetch the image:
  * the URL it drops points at Graph.
+ *
+ * A forwarded message keeps its images out of the outer body. The original
+ * travels as an attachment of type `forwardedMessageReference`, with the whole
+ * message in its `content` — as a JSON string, and nested again if that one had
+ * been forwarded too. Searching every string inside it finds the images without
+ * modelling that shape, which would only ever be one Graph change out of date.
  */
 function mapImageUrls(raw: Raw): string[] {
-	return imageUrlsInHtml(raw.body?.content ?? "");
+	const candidates: string[] = [];
+	if (typeof raw.body?.content === "string") candidates.push(raw.body.content);
+
+	for (const attachment of raw.attachments ?? []) {
+		if (typeof attachment?.content !== "string") continue;
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(attachment.content);
+		} catch {
+			// Not JSON: search it as it stands rather than dropping it.
+			candidates.push(attachment.content);
+			continue;
+		}
+		collectStrings(parsed, candidates);
+	}
+
+	return imageUrlsInHtml(candidates.join("\n"));
 }
 
 function mapMentions(raw: Raw): PersonRef[] {

package/src/graph/media.ts

@@ -142,6 +142,11 @@ export async function saveMessageFiles(
 		}
 
 		if (!attachment.contentUrl) {
+			// A forwarded message is not a file being withheld: its images and files
+			// are hosted content of the message that carries it, and they are fetched
+			// above. Listing it as unsaved would put a line of noise under every
+			// forwarded message.
+			if (attachment.contentType === "forwardedMessageReference") continue;
 			skipped.push({ name: label, reason: describeMissing(attachment) });
 			continue;
 		}

package/src/status.ts

@@ -90,6 +90,31 @@ export function buildConnectionLabel(card: ConnectionCard | undefined): string {
 	return `✓ Teams · ${scope}${card.user ? ` · ${card.user}` : ""}${listening}`;
 }
 
+/**
+ * The line a session starts with.
+ *
+ * It names listen mode on purpose. The watcher starts from the saved setting, so
+ * a session can begin polling — and answering in your name — without the
+ * transcript ever saying so, which is how a listener nobody remembers starting
+ * turns up, and how it gets to answer before anyone notices.
+ *
+ * The level is part of the answer: being listened to is the state worth a louder
+ * notice, not the ordinary one of it being off.
+ */
+export function buildStartupNotice(
+	card: ConnectionCard,
+	watch: { enabled: boolean; intervalSeconds: number },
+): { message: string; level: "info" | "warning" } {
+	const identity = `@patimweb/pi-teams loaded (${card.account}${card.user ? ` as ${card.user}` : ""}, safety: ${card.safetyLevel})`;
+
+	if (!watch.enabled) return { message: `${identity} · listen mode off`, level: "info" };
+
+	return {
+		message: `${identity} · listen mode ON — every ${watch.intervalSeconds} s, /teams-listen off to stop`,
+		level: "warning",
+	};
+}
+
 /** Rich markdown for `/teams-status` and the expanded card. */
 export function formatStatusText(card: ConnectionCard | undefined): string {
 	if (!card) {

package/src/utils/attachments.ts

@@ -11,6 +11,44 @@
  * wrong and they can be tested without a Graph call.
  */
 
+/**
+ * Every string inside a value, however it is nested.
+ *
+ * Exists for the JSON that Graph hands back for a forwarded message: the
+ * original message is in there as data of an undocumented depth, and the only
+ * thing needed from it is whatever strings it contains.
+ */
+export function collectStrings(value: unknown, out: string[] = [], depth = 0): string[] {
+	// A guard against a pathological document, not a real limit.
+	if (depth > 8) return out;
+
+	if (typeof value === "string") {
+		out.push(value);
+		// A forwarded message inside a forwarded message is JSON stored as a string
+		// inside JSON, and its quotes stay escaped until it is parsed. Without this
+		// the images two levels down are simply not there to be found.
+		const trimmed = value.trim();
+		if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+			try {
+				collectStrings(JSON.parse(trimmed), out, depth + 1);
+			} catch {
+				/* a string that merely starts with a brace */
+			}
+		}
+		return out;
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) collectStrings(entry, out, depth + 1);
+		return out;
+	}
+	if (value && typeof value === "object") {
+		for (const entry of Object.values(value as Record<string, unknown>)) {
+			collectStrings(entry, out, depth + 1);
+		}
+	}
+	return out;
+}
+
 /** Absolute URLs of the inline images in a message body, in the order shown. */
 export function imageUrlsInHtml(html: string): string[] {
 	const urls: string[] = [];