teams-cli 0.2.4__tar.gz → 0.2.5__tar.gz

{teams_cli-0.2.4 → teams_cli-0.2.5}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.5](https://github.com/rvben/teams-cli/compare/v0.2.4...v0.2.5) - 2026-10-21
+
+### Fixed
+
+- Update TLS certificate verification and bundled root certificates to address RUSTSEC-2026-0382 and RUSTSEC-2026-0383.
+- Desktop chats whose messages Teams keeps in a secondary reply-chain store (`replychains-2`, ...) no longer look empty. All such stores are now read and merged, which also fills in member names for those 1:1 chats.
+- Desktop chat messages missing from the current cache are filled in from caches the same user and tenant left under earlier display languages. Those caches no longer update, so messages edited or deleted since can appear as they were.
+- In the TUI, a chat whose messages are missing now shows its latest message from the chat list and why, instead of "No messages in this chat yet." With the desktop backend it says no messages for the chat were found in the Teams cache on this PC.
+- **deps**: update TLS certificate trust dependencies ([435b11c](https://github.com/rvben/teams-cli/commit/435b11c39113e165e843d73579bc28505ef05620))
+
 ## [0.2.4](https://github.com/rvben/teams-cli/compare/v0.2.3...v0.2.4) - 2026-10-20
 
 ### Fixed

{teams_cli-0.2.4 → teams_cli-0.2.5}/Cargo.lock

@@ -2815,9 +2815,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.15"
+version = "0.103.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -3187,7 +3187,7 @@ dependencies = [
 
 [[package]]
 name = "teams-cli"
-version = "0.2.4"
+version = "0.2.5"
 dependencies = [
  "assert_cmd",
  "base64 0.23.1",
@@ -3843,9 +3843,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-root-certs"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
+checksum = "58ec80e73fd8baf57bf0d9615554c75348bda990d6d5bbeab964dd068319fecb"
 dependencies = [
  "rustls-pki-types",
 ]

{teams_cli-0.2.4 → teams_cli-0.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "teams-cli"
-version = "0.2.4"
+version = "0.2.5"
 edition = "2024"
 rust-version = "1.90"
 description = "A Microsoft Teams CLI and TUI designed equally for humans and agents"

{teams_cli-0.2.4 → teams_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: teams-cli
-Version: 0.2.4
+Version: 0.2.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 License-File: LICENSE

{teams_cli-0.2.4 → teams_cli-0.2.5}/src/desktop.js

@@ -7,13 +7,16 @@ async (p, select) => {
     q.onsuccess = () => resolve(q.result);
     q.onerror = () => reject(q.error);
   });
-  const open = k => {
-    if (!cache[k]) throw Error('layout');
+  const openName = name => {
     // If the cache disappeared after enumeration, abort rather than create a database.
-    const q = indexedDB.open(cache[k]);
+    const q = indexedDB.open(name);
     q.onupgradeneeded = () => q.transaction.abort();
     return req(q);
   };
+  const open = k => {
+    if (!cache[k]) throw Error('layout');
+    return openName(cache[k]);
+  };
   // Missing cache timestamps can be -1. Keep sort keys valid for CLI cursors.
   const time = t => Number.isFinite(+t) && +t > 0 && +t <= 8640000000000000 ? Math.trunc(+t) : 0;
   const iso = t => time(t) ? new Date(time(t)).toISOString() : null;
@@ -64,8 +67,16 @@ async (p, select) => {
     }
     return { names, me };
   };
-  const chain = async (db, id) => (await req(db.transaction('replychains').objectStore('replychains')
-    .getAll(IDBKeyRange.bound([id], [id, []])))).flatMap(rc => Object.values(rc.messageMap || {}));
+  // Teams can split reply chains across several stores (replychains, replychains-2, ...).
+  // Numeric order keeps the primary store's copy of a message found in more than one.
+  const chain = async (db, id) => {
+    const rank = n => +(n.split('-')[1] || 1);
+    const names = [...db.objectStoreNames].filter(n => /^replychains(-\d+)?$/.test(n)).sort((a, b) => rank(a) - rank(b));
+    if (!names.length) throw Error('layout');
+    const tx = db.transaction(names);
+    const lists = await Promise.all(names.map(n => req(tx.objectStore(n).getAll(IDBKeyRange.bound([id], [id, []])))));
+    return lists.flat().flatMap(rc => Object.values((rc && rc.messageMap) || {}));
+  };
 
   const cdb = await open('conversation');
   let pg;
@@ -124,10 +135,24 @@ async (p, select) => {
       }
       return { me, items: chats.map(x => x.value), next: pg.next };
     }
+    // The current cache wins; older caches of the same account only add messages it lacks.
+    const messages = await chain(rdb, p.chat);
+    for (const name of cache.older || []) {
+      let db;
+      try {
+        db = await openName(name);
+        messages.push(...await chain(db, p.chat));
+      } catch (_) {
+        // Older caches are optional; one that vanished or changed layout is skipped.
+      } finally {
+        if (db) db.close();
+      }
+    }
     const rows = [], seen = new Set();
-    for (const m of await chain(rdb, p.chat)) {
-      if (system(m.messageType) || seen.has(m.id)) continue;
+    for (const m of messages) {
+      if (seen.has(m.id)) continue;
       seen.add(m.id);
+      if (system(m.messageType)) continue;
       rows.push({ t: time(m.originalArrivalTime), id: m.id, value: {
         id: m.id, createdDateTime: iso(m.originalArrivalTime),
         clientMessageId: typeof m.clientMessageId === 'string' ? m.clientMessageId : null,

{teams_cli-0.2.4 → teams_cli-0.2.5}/src/desktop.rs

@@ -1271,12 +1271,13 @@ mod tests {
                 .collect::<String>()
         });
         // Protocol 5 selects the signed-in cache and reports remaining ambiguity apart from surface selection.
+        // Older same-account caches are optional; a helper without them reads as before.
         assert_eq!(
             scripts,
             [
-                "32ca0293d2d5",
+                "9c000776f04a",
                 "baa0bc29c44b",
-                "025a8edc46b8",
+                "7d2b70751d6a",
                 "23b1a0e4b293"
             ]
         );

{teams_cli-0.2.4 → teams_cli-0.2.5}/src/desktop_cache.js

@@ -29,7 +29,7 @@ all => {
   }
   if (conversations.length !== 1) return { error: 'layout' };
   const conversation = conversations[0].name;
-  const account = conversation.split(':')[4];
+  const [, , , tenant, account] = conversation.split(':');
   if (!account) return { error: 'layout' };
   const related = kind => {
     const sibling = conversation.replace(':conversation-manager:', ':' + kind + ':');
@@ -37,5 +37,12 @@ all => {
     const matches = candidates(kind).filter(db => db.name.split(':')[4] === account);
     return matches.length === 1 ? matches[0].name : null;
   };
-  return { account, conversation, replies: related('replychain-manager'), profiles: related('profiles') };
+  const replies = related('replychain-manager');
+  // Caches the same user and tenant left under earlier display languages. Teams stopped
+  // updating them, so they may only fill in messages the current cache lacks.
+  const older = candidates('replychain-manager').map(db => db.name).filter(name => {
+    const part = name.split(':');
+    return name !== replies && part[3] === tenant && part[4] === account;
+  }).sort();
+  return { account, conversation, replies, profiles: related('profiles'), older };
 }

{teams_cli-0.2.4 → teams_cli-0.2.5}/src/tui.rs

@@ -532,6 +532,16 @@ impl App {
         }
     }
 
+    /// Why a chat shows only its latest message, said for where messages come from.
+    fn missing_history_note(&self) -> &'static str {
+        match self.backend().as_deref() {
+            Some(TeamsBackend::Desktop(_)) => {
+                "No messages for this chat were found in the Teams cache on this PC. Latest message:"
+            }
+            _ => "Only the latest message is available.",
+        }
+    }
+
     fn can_send(&self) -> bool {
         match &self.source {
             Source::Live { can_send, .. } => *can_send,
@@ -2030,7 +2040,21 @@ impl App {
             }
             Load::Ready => {}
         }
-        let entries = render::conversation(&thread.items, &self.view(), self.viewer.as_deref());
+        let mut entries = render::conversation(&thread.items, &self.view(), self.viewer.as_deref());
+        // The chat list can carry a latest message whose history was never read.
+        let mut missing = false;
+        if entries.is_empty()
+            && thread.cursor.is_none()
+            && let Some(chat) = self.chats.iter().find(|chat| chat["id"] == id.as_str())
+            && chat["lastMessagePreview"].is_object()
+        {
+            entries = render::conversation(
+                std::slice::from_ref(&chat["lastMessagePreview"]),
+                &self.view(),
+                self.viewer.as_deref(),
+            );
+            missing = !entries.is_empty();
+        }
         let mut lines = Vec::new();
         if thread.loading_older {
             lines.push(
@@ -2050,7 +2074,12 @@ impl App {
                 .alignment(Alignment::Center),
             );
         }
-        if entries.is_empty() {
+        if missing {
+            lines.push(Line::raw(""));
+            for note in render::wrap(self.missing_history_note(), usize::from(body.width)) {
+                lines.push(Line::styled(note, theme.muted()).centered());
+            }
+        } else if entries.is_empty() {
             lines.push(Line::raw(""));
             lines.push(Line::styled("No messages in this chat yet.", theme.muted()).centered());
         }
@@ -3706,6 +3735,66 @@ mod tests {
         App::new(source, Theme { color: false }, now)
     }
 
+    #[test]
+    fn a_chat_without_history_shows_its_latest_message_and_why() {
+        let empty = |app: &mut App| {
+            let id = app.selected_row().unwrap().id.clone();
+            app.threads.insert(
+                id,
+                Thread {
+                    items: Vec::new(),
+                    cursor: None,
+                    load: Load::Ready,
+                    loading_older: false,
+                    fetching: false,
+                },
+            );
+            frame_text(app)
+        };
+        let mut app = demo_app();
+        let text = empty(&mut app);
+        assert!(
+            text.contains("Only the latest message is available."),
+            "{text}"
+        );
+        assert!(text.contains("release candidate is green"), "{text}");
+        assert!(!text.contains("No messages in this chat yet."), "{text}");
+
+        let now = app.now.clone();
+        let mut app = live_app(false, "work");
+        app.source = Source::Live {
+            backend: Arc::new(TeamsBackend::Desktop(Box::new(
+                crate::desktop::DesktopClient::new(19224).unwrap(),
+            ))),
+            profile: "work".into(),
+            can_send: false,
+        };
+        app.apply(Outcome::Chats {
+            more: false,
+            result: Ok(demo_chats(&now)),
+        });
+        let text = empty(&mut app);
+        assert!(text.contains("were found in the Teams cache"), "{text}");
+        // The note wraps with the pane rather than being cut off.
+        let mut terminal = Terminal::new(TestBackend::new(60, 24)).unwrap();
+        app.focus = Focus::Thread;
+        terminal.draw(|frame| app.draw(frame)).unwrap();
+        let narrow = buffer_text(terminal.backend().buffer());
+        assert!(narrow.contains("Latest message:"), "{narrow}");
+        assert!(text.contains("release candidate is green"), "{text}");
+
+        // Older pages may still hold messages, so nothing is claimed missing.
+        let id = app.selected_row().unwrap().id.clone();
+        app.threads.get_mut(&id).unwrap().cursor = Some("older".into());
+        let text = frame_text(&mut app);
+        assert!(text.contains("No messages in this chat yet."), "{text}");
+
+        // Without a preview there is nothing to show.
+        app.chats[0]["lastMessagePreview"] = Value::Null;
+        let text = empty(&mut app);
+        assert!(text.contains("No messages in this chat yet."), "{text}");
+    }
+
     #[test]
     fn the_header_shows_the_profile_send_mode_freshness_and_counts() {
         let mut app = demo_app();

{teams_cli-0.2.4 → teams_cli-0.2.5}/tests/desktop_scripts.test.cjs

@@ -29,7 +29,7 @@ function cursor(records) {
   return q;
 }
 
-function fixture({ ambiguous = false, foreignOnly = false, mutate, timeout = false, core = false } = {}) {
+function fixture({ ambiguous = false, foreignOnly = false, older = [], stores = {}, mutate, timeout = false, core = false } = {}) {
   const databases = new Map([
     [name('conversation-manager', 'account-a'), [conversation]],
     [name('replychain-manager', 'account-b'), [{ chat, messageMap: { b: { ...message, content: 'Wrong account' } } }]],
@@ -40,6 +40,9 @@ function fixture({ ambiguous = false, foreignOnly = false, mutate, timeout = fal
     databases.set(name('profiles', 'account-a'), [{ mri: '8:orgid:sender', displayName: 'Correct Name' }]);
   }
   if (ambiguous) databases.set(name('conversation-manager', 'account-b'), [conversation]);
+  for (const [locale, records] of older) databases.set(name('replychain-manager', 'account-a') + ':' + locale, records);
+  // Extra object stores of the current account's reply-chain database, beside its default store.
+  const extra = new Map([[name('replychain-manager', 'account-a'), stores]]);
   const opened = [], mutations = [];
   let inspections = 0;
   const client = { mutate: options => {
@@ -55,11 +58,15 @@ function fixture({ ambiguous = false, foreignOnly = false, mutate, timeout = fal
       open: database => {
         assert.ok(databases.has(database), `Unknown database: ${database}`);
         opened.push(database);
-        return request({ name: database, close() {}, transaction: () => ({ objectStore: () => ({
-          get: id => request(databases.get(database).find(record => (record.mri || record.id) === id)),
-          getAll: range => request(databases.get(database).filter(record => !range || record.chat === range.chat)),
-          openCursor: () => cursor(databases.get(database)),
-        }) }) });
+        const named = extra.get(database) || {};
+        const records = store => store in named ? named[store] : databases.get(database);
+        return request({ name: database, close() {},
+          objectStoreNames: database.includes(':replychain-manager:') ? ['replychains', ...Object.keys(named)] : [],
+          transaction: () => ({ objectStore: store => ({
+            get: id => request(records(store).find(record => (record.mri || record.id) === id)),
+            getAll: range => request(records(store).filter(record => !range || record.chat === range.chat)),
+            openCursor: () => cursor(records(store)),
+          }) }) });
       },
     },
     IDBKeyRange: { bound: a => ({ chat: a[0] }) },
@@ -225,6 +232,57 @@ for (const query of ['chats', 'messages']) {
   });
 }
 
+test('older caches of the same account only add messages the current cache lacks', async () => {
+  const earlier = { ...message, id: '1690000000000', originalArrivalTime: 1690000000000, content: 'Earlier' };
+  const f = fixture({ older: [
+    ['nl-nl', [{ chat, messageMap: { stale: { ...message, content: 'Stale' }, earlier } }]],
+    ['de-de', [{ chat: '19:other@thread.v2', messageMap: { other: { ...message, id: '1680000000000', content: 'Other chat' } } }]],
+  ] });
+  const result = await f.read();
+  assert.deepEqual([...result.items.map(item => item.body.content)], [message.content, 'Earlier']);
+  assert.ok(f.opened.every(database => !database.includes(':account-b')));
+});
+
+test('messages filed only in a later reply-chain store are read', async () => {
+  const f = fixture({ stores: {
+    'replychains-2': [{ chat, messageMap: { a: message } }],
+    'unrelated': [{ chat, messageMap: { x: { ...message, id: '1710000000000', content: 'Unrelated store' } } }],
+  } });
+  f.databases.set(name('replychain-manager', 'account-a'), []);
+  const result = await f.read();
+  assert.deepEqual([...result.items.map(item => item.body.content)], [message.content]);
+});
+
+test('messages split across reply-chain stores are merged newest first without duplicates', async () => {
+  const earlier = { ...message, id: '1690000000000', originalArrivalTime: 1690000000000, content: 'Earlier' };
+  const later = { ...message, id: '1710000000000', originalArrivalTime: 1710000000000, content: 'Later' };
+  const f = fixture({ stores: { 'replychains-2': [{ chat, messageMap: { a: message, earlier, later } }] } });
+  const result = await f.read();
+  assert.deepEqual([...result.items.map(item => item.body.content)], ['Later', message.content, 'Earlier']);
+});
+
+test('reply-chain stores are read in numeric order, so the primary copy of a message wins', async () => {
+  const f = fixture({ stores: {
+    'replychains-10': [{ chat, messageMap: { a: { ...message, content: 'Tenth store' } } }],
+    'replychains-2': [{ chat, messageMap: { a: { ...message, content: 'Second store' } } }],
+  } });
+  assert.deepEqual([...(await f.read()).items.map(item => item.body.content)], [message.content]);
+  f.databases.set(name('replychain-manager', 'account-a'), []);
+  assert.deepEqual([...(await f.read()).items.map(item => item.body.content)], ['Second store']);
+});
+
+test('1:1 member names come from messages in a later reply-chain store', async () => {
+  const one = '19:account-a_peer@unq.gbl.spaces';
+  const f = fixture({ stores: { 'replychains-2': [{ chat: one, messageMap: {
+    p: { ...message, creator: '8:orgid:peer', imDisplayName: 'Peer Name' },
+  } }] } });
+  f.databases.set(name('conversation-manager', 'account-a'), [{ ...conversation, id: one, members: [] }]);
+  f.databases.set(name('replychain-manager', 'account-a'), []);
+  const result = await f.read({ query: 'chats', chat: '' });
+  assert.equal(result.me, 'account-a');
+  assert.equal(result.items[0].members.find(m => m.userId === 'peer').displayName, 'Peer Name');
+});
+
 test('a missing account database never falls back to another account', async () => {
   const f = fixture({ foreignOnly: true });
   await assert.rejects(f.read(), /layout/);
@@ -251,10 +309,12 @@ test('the signed-in user, tenant and display language select among coexisting ca
     ...caches('home', 'me', 'en-us'), ...caches('home', 'me', 'nl-nl'),
     ...caches('guest', 'me-as-guest'), ...caches('home', 'colleague'),
   ];
-  for (const [tenant, user, locale] of [['home', 'me', 'nl-nl'], ['home', 'me', 'en-us'], ['guest', 'me-as-guest', 'en-us']]) {
+  for (const [tenant, user, locale, older] of [['home', 'me', 'nl-nl', ['en-us']], ['home', 'me', 'en-us', ['nl-nl']], ['guest', 'me-as-guest', 'en-us', []]]) {
     assert.deepEqual(selectWith(names, signedIn(tenant, user, locale)), {
       account: user, conversation: teams('conversation-manager', tenant, user, locale),
       replies: teams('replychain-manager', tenant, user, locale), profiles: teams('profiles', tenant, user, locale),
+      // Only the same user in the same tenant may fill in messages.
+      older: older.map(other => teams('replychain-manager', tenant, user, other)),
     });
   }
   // Only one cache for the signed-in account needs no display language.