msteams-mcp 0.2.0 → 0.3.1

package/dist/auth/token-extractor.js

@@ -5,6 +5,30 @@
  */
 import { readSessionState, readTokenCache, writeTokenCache, clearTokenCache, getTeamsOrigin, } from './session-store.js';
 import { parseJwtProfile } from '../utils/parsers.js';
+/**
+ * Decodes a JWT token's payload without verifying the signature.
+ * Returns null if the token is invalid.
+ */
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length < 2)
+            return null;
+        return JSON.parse(Buffer.from(parts[1], 'base64').toString());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Gets the expiry date from a JWT token.
+ */
+function getJwtExpiry(token) {
+    const payload = decodeJwtPayload(token);
+    if (!payload?.exp || typeof payload.exp !== 'number')
+        return null;
+    return new Date(payload.exp * 1000);
+}
 /**
  * Extracts the Substrate search token from session state.
  */
@@ -22,10 +46,8 @@ export function extractSubstrateToken(state) {
                 const token = val.secret;
                 if (!token || typeof token !== 'string')
                     continue;
-                const parts = token.split('.');
-                if (parts.length === 3) {
-                    const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-                    const expiry = new Date(payload.exp * 1000);
+                const expiry = getJwtExpiry(token);
+                if (expiry) {
                     return { token, expiry };
                 }
             }
@@ -107,13 +129,12 @@ export function extractTeamsToken(state) {
             const secret = val.secret;
             if (typeof secret !== 'string' || !secret.startsWith('ey'))
                 continue;
-            const parts = secret.split('.');
-            if (parts.length !== 3)
+            const payload = decodeJwtPayload(secret);
+            if (!payload?.exp || typeof payload.exp !== 'number')
                 continue;
-            const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
             const tokenExpiry = new Date(payload.exp * 1000);
             // Extract user MRI from any token
-            if (payload.oid && !userMri) {
+            if (typeof payload.oid === 'string' && !userMri) {
                 userMri = `8:orgid:${payload.oid}`;
             }
             // Prefer chatsvcagg.teams.microsoft.com token
@@ -139,17 +160,9 @@ export function extractTeamsToken(state) {
     if (!userMri) {
         const substrateInfo = extractSubstrateToken(sessionState);
         if (substrateInfo) {
-            try {
-                const parts = substrateInfo.token.split('.');
-                if (parts.length === 3) {
-                    const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-                    if (payload.oid) {
-                        userMri = `8:orgid:${payload.oid}`;
-                    }
-                }
-            }
-            catch {
-                // Ignore
+            const payload = decodeJwtPayload(substrateInfo.token);
+            if (typeof payload?.oid === 'string') {
+                userMri = `8:orgid:${payload.oid}`;
             }
         }
     }
@@ -185,32 +198,16 @@ export function extractMessageAuth(state) {
     }
     // Get userMri from skypeToken payload
     if (skypeToken) {
-        try {
-            const parts = skypeToken.split('.');
-            if (parts.length >= 2) {
-                const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-                if (payload.skypeid) {
-                    userMri = payload.skypeid;
-                }
-            }
-        }
-        catch {
-            // Not a JWT format, that's fine
+        const payload = decodeJwtPayload(skypeToken);
+        if (typeof payload?.skypeid === 'string') {
+            userMri = payload.skypeid;
         }
     }
     // Fallback to extracting userMri from authToken
     if (!userMri && authToken) {
-        try {
-            const parts = authToken.split('.');
-            if (parts.length === 3) {
-                const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-                if (payload.oid) {
-                    userMri = `8:orgid:${payload.oid}`;
-                }
-            }
-        }
-        catch {
-            // Ignore
+        const payload = decodeJwtPayload(authToken);
+        if (typeof payload?.oid === 'string') {
+            userMri = `8:orgid:${payload.oid}`;
         }
     }
     if (skypeToken && authToken && userMri) {
@@ -252,7 +249,6 @@ export function getUserProfile(state) {
     const teamsOrigin = getTeamsOrigin(sessionState);
     if (!teamsOrigin)
         return null;
-    // Look through localStorage for any JWT with user info
     for (const item of teamsOrigin.localStorage) {
         try {
             const val = JSON.parse(item.value);
@@ -260,13 +256,11 @@ export function getUserProfile(state) {
                 continue;
             if (!val.secret.startsWith('ey'))
                 continue;
-            const parts = val.secret.split('.');
-            if (parts.length !== 3)
-                continue;
-            const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-            const profile = parseJwtProfile(payload);
-            if (profile) {
-                return profile;
+            const payload = decodeJwtPayload(val.secret);
+            if (payload) {
+                const profile = parseJwtProfile(payload);
+                if (profile)
+                    return profile;
             }
         }
         catch {
@@ -302,17 +296,9 @@ export function getUserDisplayName(state) {
     // Try to get from token
     const teamsToken = extractTeamsToken(sessionState);
     if (teamsToken) {
-        try {
-            const parts = teamsToken.token.split('.');
-            if (parts.length === 3) {
-                const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-                if (payload.name)
-                    return payload.name;
-            }
-        }
-        catch {
-            // Ignore
-        }
+        const payload = decodeJwtPayload(teamsToken.token);
+        if (typeof payload?.name === 'string')
+            return payload.name;
     }
     return null;
 }

package/dist/auth/token-refresh.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Token refresh via headless browser.
+ *
+ * Teams uses SPA OAuth2 which restricts refresh tokens to browser-based CORS
+ * requests. We open a headless browser with saved session state, let MSAL
+ * silently refresh tokens, then save the updated state. Seamless to the user.
+ */
+import { type Result } from '../types/result.js';
+/** Result of a successful token refresh. */
+export interface TokenRefreshResult {
+    /** New token expiry time. */
+    newExpiry: Date;
+    /** Previous expiry time (for comparison). */
+    previousExpiry: Date;
+    /** Minutes gained by refresh. */
+    minutesGained: number;
+    /** Whether a refresh was actually needed (token was close to expiry). */
+    refreshNeeded: boolean;
+}
+/**
+ * Refreshes tokens by opening a headless browser with saved session state.
+ * MSAL refreshes tokens automatically when Teams loads; we just need to
+ * trigger that and save the updated state.
+ */
+export declare function refreshTokensViaBrowser(): Promise<Result<TokenRefreshResult>>;
+/**
+ * Checks if tokens need refreshing (less than threshold time remaining).
+ *
+ * @returns true if tokens should be refreshed proactively
+ */
+export declare function shouldRefreshToken(): boolean;
+/**
+ * Checks if tokens are completely expired.
+ *
+ * @returns true if tokens have expired and cannot be used
+ */
+export declare function isTokenExpired(): boolean;
+/**
+ * Attempts to proactively refresh tokens if they're approaching expiry.
+ *
+ * This is a convenience function that checks if refresh is needed and
+ * performs it if necessary. Safe to call on any operation - it only
+ * opens a browser when actually needed.
+ *
+ * @returns The refresh result if refresh was attempted, null if not needed
+ */
+export declare function refreshIfNeeded(): Promise<Result<TokenRefreshResult> | null>;

package/dist/auth/token-refresh.js

@@ -0,0 +1,121 @@
+/**
+ * Token refresh via headless browser.
+ *
+ * Teams uses SPA OAuth2 which restricts refresh tokens to browser-based CORS
+ * requests. We open a headless browser with saved session state, let MSAL
+ * silently refresh tokens, then save the updated state. Seamless to the user.
+ */
+import { TOKEN_REFRESH_THRESHOLD_MS, MSAL_TOKEN_DELAY_MS } from '../constants.js';
+import { ErrorCode, createError } from '../types/errors.js';
+import { ok, err } from '../types/result.js';
+import { extractSubstrateToken, clearTokenCache, } from './token-extractor.js';
+import { hasSessionState, isSessionLikelyExpired, } from './session-store.js';
+/**
+ * Refreshes tokens by opening a headless browser with saved session state.
+ * MSAL refreshes tokens automatically when Teams loads; we just need to
+ * trigger that and save the updated state.
+ */
+export async function refreshTokensViaBrowser() {
+    // Check we have a session to work with
+    if (!hasSessionState()) {
+        return err(createError(ErrorCode.AUTH_REQUIRED, 'No session state available. Please run teams_login to authenticate.', { suggestions: ['Call teams_login to authenticate'] }));
+    }
+    if (isSessionLikelyExpired()) {
+        return err(createError(ErrorCode.AUTH_EXPIRED, 'Session is too old and likely expired. Please re-authenticate.', { suggestions: ['Call teams_login to re-authenticate'] }));
+    }
+    // Get current token expiry for comparison
+    const beforeToken = extractSubstrateToken();
+    if (!beforeToken) {
+        return err(createError(ErrorCode.AUTH_REQUIRED, 'No token found in session. Please run teams_login to authenticate.', { suggestions: ['Call teams_login to authenticate'] }));
+    }
+    const previousExpiry = beforeToken.expiry;
+    // Import browser functions dynamically to avoid circular dependencies
+    const { createBrowserContext, closeBrowser } = await import('../browser/context.js');
+    let manager = null;
+    try {
+        // Open headless browser with saved session
+        manager = await createBrowserContext({ headless: true });
+        // Navigate to Teams - this triggers MSAL to check/refresh tokens
+        await manager.page.goto('https://teams.microsoft.com', {
+            waitUntil: 'domcontentloaded',
+        });
+        // Wait for MSAL to refresh tokens in the background
+        // The token storage happens asynchronously after page load
+        await manager.page.waitForTimeout(MSAL_TOKEN_DELAY_MS);
+        // Close browser and save session state (this captures the refreshed tokens)
+        await closeBrowser(manager, true);
+        manager = null;
+        // Clear our token cache to force re-extraction from the new session
+        clearTokenCache();
+        // Extract the new token to verify we still have valid tokens
+        const afterToken = extractSubstrateToken();
+        if (!afterToken) {
+            return err(createError(ErrorCode.AUTH_EXPIRED, 'Token refresh failed - no token found after refresh attempt.', { suggestions: ['Call teams_login to re-authenticate'] }));
+        }
+        const newExpiry = afterToken.expiry;
+        const minutesGained = Math.round((newExpiry.getTime() - previousExpiry.getTime()) / 1000 / 60);
+        // Check if the token was close to expiry and needed refresh
+        const wasCloseToExpiry = previousExpiry.getTime() - Date.now() < TOKEN_REFRESH_THRESHOLD_MS;
+        // If we needed a refresh but didn't get one, that's an error
+        if (wasCloseToExpiry && newExpiry.getTime() <= previousExpiry.getTime()) {
+            return err(createError(ErrorCode.AUTH_EXPIRED, 'Token was not refreshed despite being close to expiry. Session may need re-authentication.', { suggestions: ['Call teams_login to re-authenticate'] }));
+        }
+        return ok({
+            newExpiry,
+            previousExpiry,
+            minutesGained,
+            refreshNeeded: wasCloseToExpiry,
+        });
+    }
+    catch (error) {
+        // Clean up browser if still open
+        if (manager) {
+            try {
+                await closeBrowser(manager, false);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return err(createError(ErrorCode.UNKNOWN, `Token refresh via browser failed: ${message}`, { suggestions: ['Call teams_login to re-authenticate'] }));
+    }
+}
+/**
+ * Checks if tokens need refreshing (less than threshold time remaining).
+ *
+ * @returns true if tokens should be refreshed proactively
+ */
+export function shouldRefreshToken() {
+    const substrate = extractSubstrateToken();
+    if (!substrate)
+        return false;
+    const timeRemaining = substrate.expiry.getTime() - Date.now();
+    return timeRemaining > 0 && timeRemaining < TOKEN_REFRESH_THRESHOLD_MS;
+}
+/**
+ * Checks if tokens are completely expired.
+ *
+ * @returns true if tokens have expired and cannot be used
+ */
+export function isTokenExpired() {
+    const substrate = extractSubstrateToken();
+    if (!substrate)
+        return true;
+    return substrate.expiry.getTime() <= Date.now();
+}
+/**
+ * Attempts to proactively refresh tokens if they're approaching expiry.
+ *
+ * This is a convenience function that checks if refresh is needed and
+ * performs it if necessary. Safe to call on any operation - it only
+ * opens a browser when actually needed.
+ *
+ * @returns The refresh result if refresh was attempted, null if not needed
+ */
+export async function refreshIfNeeded() {
+    if (!shouldRefreshToken()) {
+        return null;
+    }
+    return refreshTokensViaBrowser();
+}

package/dist/constants.d.ts

@@ -52,3 +52,13 @@ export declare const RETRY_BASE_DELAY_MS = 1000;
 export declare const RETRY_MAX_DELAY_MS = 10000;
 /** Self-chat (notes) conversation ID. */
 export declare const SELF_CHAT_ID = "48:notes";
+/** Activity feed (notifications) conversation ID. */
+export declare const NOTIFICATIONS_ID = "48:notifications";
+/** Default limit for activity feed items. */
+export declare const DEFAULT_ACTIVITY_LIMIT = 50;
+/** Maximum limit for activity feed items. */
+export declare const MAX_ACTIVITY_LIMIT = 200;
+/** Maximum conversations to check when aggregating unread status. */
+export declare const MAX_UNREAD_AGGREGATE_CHECK = 20;
+/** Threshold for proactive token refresh (10 minutes before expiry). */
+export declare const TOKEN_REFRESH_THRESHOLD_MS: number;

package/dist/constants.js

@@ -70,3 +70,22 @@ export const RETRY_MAX_DELAY_MS = 10000;
 // ─────────────────────────────────────────────────────────────────────────────
 /** Self-chat (notes) conversation ID. */
 export const SELF_CHAT_ID = '48:notes';
+/** Activity feed (notifications) conversation ID. */
+export const NOTIFICATIONS_ID = '48:notifications';
+// ─────────────────────────────────────────────────────────────────────────────
+// Activity Feed
+// ─────────────────────────────────────────────────────────────────────────────
+/** Default limit for activity feed items. */
+export const DEFAULT_ACTIVITY_LIMIT = 50;
+/** Maximum limit for activity feed items. */
+export const MAX_ACTIVITY_LIMIT = 200;
+// ─────────────────────────────────────────────────────────────────────────────
+// Unread Status
+// ─────────────────────────────────────────────────────────────────────────────
+/** Maximum conversations to check when aggregating unread status. */
+export const MAX_UNREAD_AGGREGATE_CHECK = 20;
+// ─────────────────────────────────────────────────────────────────────────────
+// Token Refresh
+// ─────────────────────────────────────────────────────────────────────────────
+/** Threshold for proactive token refresh (10 minutes before expiry). */
+export const TOKEN_REFRESH_THRESHOLD_MS = 10 * 60 * 1000;

package/dist/test/cli.js

@@ -13,6 +13,7 @@ import { createBrowserContext, closeBrowser } from '../browser/context.js';
 import { ensureAuthenticated, forceNewLogin } from '../browser/auth.js';
 import { hasSessionState, getSessionAge, clearSessionState, } from '../auth/session-store.js';
 import { hasValidSubstrateToken, getSubstrateTokenStatus, extractMessageAuth, getUserProfile, clearTokenCache, } from '../auth/token-extractor.js';
+import { refreshTokensViaBrowser } from '../auth/token-refresh.js';
 import { searchMessages } from '../api/substrate-api.js';
 import { sendMessage, sendNoteToSelf } from '../api/chatsvc-api.js';
 function parseArgs() {
@@ -64,6 +65,7 @@ Commands:
   me                  Get current user profile (email, name, Teams ID)
   login               Log in to Teams (opens browser)
   login --force       Force new login (clears existing session)
+  refresh             Test OAuth token refresh (shows before/after status)
   help                Show this help message
 
 Options:
@@ -84,17 +86,27 @@ Examples:
   npm run cli -- search "query" --from 25
   npm run cli -- send "Test message to myself"
   npm run cli -- login --force
+  npm run cli -- refresh
 `);
 }
 async function commandStatus(flags) {
     const hasSession = hasSessionState();
     const sessionAge = getSessionAge();
-    const tokenStatus = getSubstrateTokenStatus();
+    const substrateStatus = getSubstrateTokenStatus();
+    const messageAuth = extractMessageAuth();
+    // Check if refresh will trigger soon (within 10 minutes)
+    const REFRESH_THRESHOLD_MINS = 10;
+    const willRefreshSoon = substrateStatus.minutesRemaining !== undefined &&
+        substrateStatus.minutesRemaining <= REFRESH_THRESHOLD_MINS;
     const status = {
-        directApi: {
-            available: tokenStatus.hasToken,
-            expiresAt: tokenStatus.expiresAt,
-            minutesRemaining: tokenStatus.minutesRemaining,
+        search: {
+            available: substrateStatus.hasToken,
+            expiresAt: substrateStatus.expiresAt,
+            minutesRemaining: substrateStatus.minutesRemaining,
+            willAutoRefresh: willRefreshSoon,
+        },
+        messaging: {
+            available: !!messageAuth,
         },
         session: {
             exists: hasSession,
@@ -106,20 +118,44 @@ async function commandStatus(flags) {
         console.log(JSON.stringify(status, null, 2));
     }
     else {
-        console.log('\n📊 Status\n');
-        if (status.directApi.available) {
-            console.log(`Direct API: ✅ Available (${status.directApi.minutesRemaining} min remaining)`);
+        console.log('\n📊 Token Status\n');
+        // Search token (Substrate)
+        console.log('Search API (Substrate):');
+        if (status.search.available) {
+            console.log(`   Status: ✅ Valid`);
+            console.log(`   Expires: ${status.search.expiresAt}`);
+            console.log(`   Remaining: ${status.search.minutesRemaining} minutes`);
+            if (status.search.willAutoRefresh) {
+                console.log(`   ⚡ Auto-refresh will trigger (< ${REFRESH_THRESHOLD_MINS} min remaining)`);
+            }
+        }
+        else {
+            console.log('   Status: ❌ No valid token');
+        }
+        // Messaging token (Skype)
+        console.log('\nMessaging API (Skype):');
+        if (status.messaging.available) {
+            console.log('   Status: ✅ Valid');
         }
         else {
-            console.log('Direct API: ❌ No valid token (browser login required)');
+            console.log('   Status: ❌ No valid token');
         }
-        console.log(`Session exists: ${status.session.exists ? '✅ Yes' : '❌ No'}`);
+        // Session info
+        console.log('\nSession:');
+        console.log(`   Exists: ${status.session.exists ? '✅ Yes' : '❌ No'}`);
         if (status.session.ageHours !== null) {
-            console.log(`Session age: ${status.session.ageHours} hours`);
+            console.log(`   Age: ${status.session.ageHours} hours`);
             if (status.session.likelyExpired) {
-                console.log('⚠️  Session may be expired');
+                console.log('   ⚠️  Session may be expired (>12 hours old)');
             }
         }
+        // Action hint
+        if (!status.search.available || !status.messaging.available) {
+            console.log('\n💡 Run: npm run cli -- login');
+        }
+        else if (status.search.willAutoRefresh) {
+            console.log('\n💡 Run: npm run cli -- refresh (to test auto-refresh)');
+        }
     }
 }
 async function commandSearch(query, flags, options) {
@@ -267,6 +303,79 @@ async function commandMe(flags) {
         }
     }
 }
+async function commandRefresh(flags) {
+    const asJson = flags.has('json');
+    // Show current status
+    const beforeStatus = getSubstrateTokenStatus();
+    if (!asJson) {
+        console.log('\n🔄 Token Refresh Test\n');
+        console.log('Before refresh:');
+        if (beforeStatus.hasToken) {
+            console.log(`   Token valid: ✅ Yes`);
+            console.log(`   Expires at: ${beforeStatus.expiresAt}`);
+            console.log(`   Minutes remaining: ${beforeStatus.minutesRemaining}`);
+        }
+        else {
+            console.log(`   Token valid: ❌ No`);
+        }
+        console.log('\nOpening headless browser to refresh tokens...');
+    }
+    // Attempt refresh via headless browser
+    const result = await refreshTokensViaBrowser();
+    if (!result.ok) {
+        if (asJson) {
+            console.log(JSON.stringify({
+                success: false,
+                error: result.error.message,
+                code: result.error.code,
+                before: beforeStatus,
+            }, null, 2));
+        }
+        else {
+            console.log(`\n❌ Refresh failed: ${result.error.message}`);
+            if (result.error.code) {
+                console.log(`   Error code: ${result.error.code}`);
+            }
+            if (result.error.suggestions) {
+                console.log(`   Suggestions: ${result.error.suggestions.join(', ')}`);
+            }
+        }
+        process.exit(1);
+    }
+    // Show new status
+    const afterStatus = getSubstrateTokenStatus();
+    if (asJson) {
+        console.log(JSON.stringify({
+            success: true,
+            before: beforeStatus,
+            after: afterStatus,
+            refreshResult: {
+                previousExpiry: result.value.previousExpiry.toISOString(),
+                newExpiry: result.value.newExpiry.toISOString(),
+                minutesGained: result.value.minutesGained,
+                refreshNeeded: result.value.refreshNeeded,
+            },
+        }, null, 2));
+    }
+    else {
+        if (result.value.refreshNeeded) {
+            console.log('\n✅ Token refreshed!\n');
+            console.log('After refresh:');
+            console.log(`   Token valid: ✅ Yes`);
+            console.log(`   Expires at: ${afterStatus.expiresAt}`);
+            console.log(`   Minutes remaining: ${afterStatus.minutesRemaining}`);
+            console.log(`   Time gained: +${result.value.minutesGained} minutes`);
+        }
+        else {
+            console.log('\n✅ Token is still valid (no refresh needed)\n');
+            console.log('Current token:');
+            console.log(`   Expires at: ${afterStatus.expiresAt}`);
+            console.log(`   Minutes remaining: ${afterStatus.minutesRemaining}`);
+            console.log('\n   Note: MSAL only refreshes tokens when they\'re close to expiry.');
+            console.log('   Proactive refresh will trigger when <10 minutes remain.');
+        }
+    }
+}
 async function commandLogin(flags) {
     const force = flags.has('force');
     if (force) {
@@ -311,6 +420,9 @@ async function main() {
             case 'me':
                 await commandMe(flags);
                 break;
+            case 'refresh':
+                await commandRefresh(flags);
+                break;
             case 'login':
                 await commandLogin(flags);
                 break;

package/dist/test/mcp-harness.js

@@ -33,6 +33,9 @@ const SHORTCUTS = {
     contacts: { tool: 'teams_get_frequent_contacts' },
     channel: { tool: 'teams_find_channel', primaryArg: 'query' },
     chat: { tool: 'teams_get_chat', primaryArg: 'userId' },
+    unread: { tool: 'teams_get_unread' },
+    markread: { tool: 'teams_mark_read' },
+    activity: { tool: 'teams_get_activity' },
 };
 // Map CLI flags to tool parameter names
 const FLAG_MAPPINGS = {
@@ -48,6 +51,7 @@ const FLAG_MAPPINGS = {
     '--force': 'forceNew',
     '--user': 'userId',
     '--userId': 'userId',
+    '--markRead': 'markRead',
 };
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -251,6 +255,9 @@ function prettyPrintResponse(response, toolName) {
     else if (response.messages && Array.isArray(response.messages)) {
         printMessagesList(response.messages);
     }
+    else if (response.activities && Array.isArray(response.activities)) {
+        printActivityList(response.activities);
+    }
     else if (response.contacts && Array.isArray(response.contacts)) {
         printContactsList(response.contacts);
     }
@@ -340,6 +347,30 @@ function printContactsList(contacts) {
         log('');
     }
 }
+function printActivityList(activities) {
+    log(`Found ${activities.length} activity items:\n`);
+    const typeIcons = {
+        mention: '📣',
+        reaction: '👍',
+        reply: '💬',
+        message: '📝',
+        unknown: '❓',
+    };
+    for (const a of activities) {
+        const activity = a;
+        const type = activity.type || 'unknown';
+        const icon = typeIcons[type] || '❓';
+        const sender = activity.sender?.displayName || 'Unknown';
+        const time = activity.timestamp ? new Date(activity.timestamp).toLocaleString() : '';
+        const topic = activity.topic ? ` in "${activity.topic}"` : '';
+        const preview = String(activity.content ?? '').substring(0, 80).replace(/\n/g, ' ');
+        log(`${icon} [${type}] ${sender}${topic} - ${time}`);
+        log(`   ${preview}${String(activity.content ?? '').length > 80 ? '...' : ''}`);
+        if (activity.conversationId)
+            log(`   ConversationId: ${activity.conversationId}`);
+        log('');
+    }
+}
 function printProfile(profile) {
     log('👤 Profile:\n');
     for (const [key, value] of Object.entries(profile)) {