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

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

@@ -7,6 +7,27 @@ 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
+
+- When Teams keeps caches for several accounts, guest organizations or display languages, the desktop backend now reads the one for the signed-in user, tenant and display language instead of refusing.
+
+### Changed
+
+- Desktop errors now tell apart two cases: personal and work/school Teams both being open, which `--desktop-account` resolves, and one surface holding cached data for several accounts or organizations, which it does not.
+- Windows desktop helpers use protocol 5. WSL requires the helper from the same CLI release.
+
 ## [0.2.3](https://github.com/rvben/teams-cli/compare/v0.2.2...v0.2.3) - 2026-10-16
 
 ### Fixed

{teams_cli-0.2.3 → 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.3"
+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.3 → teams_cli-0.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "teams-cli"
-version = "0.2.3"
+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.3 → teams_cli-0.2.5}/PKG-INFO

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

{teams_cli-0.2.3 → teams_cli-0.2.5}/src/desktop/browser.rs

@@ -1690,9 +1690,11 @@ mod tests {
         .unwrap();
         std::fs::set_permissions(&browser, std::fs::Permissions::from_mode(0o700)).unwrap();
         let started = std::time::Instant::now();
-        let error = browser_version_with_timeout(&browser, Duration::from_millis(100)).unwrap_err();
+        // Fresh executable inspection on macOS can exceed 100 ms before the
+        // script writes its PID. Allow startup while still bounding the hang.
+        let error = browser_version_with_timeout(&browser, Duration::from_secs(1)).unwrap_err();
         assert!(error.to_string().contains("timed out"));
-        assert!(started.elapsed() < Duration::from_secs(2));
+        assert!(started.elapsed() < Duration::from_secs(3));
         let pid: i32 = std::fs::read_to_string(dir.path().join("browser.pid"))
             .unwrap()
             .parse()

{teams_cli-0.2.3 → teams_cli-0.2.5}/src/desktop/helper.rs

@@ -10,7 +10,7 @@ use crate::error::AppError;
 use serde_json::{Value, json};
 use tokio::io::{AsyncBufRead, AsyncBufReadExt, AsyncWrite, AsyncWriteExt};
 
-pub const PROTOCOL: u32 = 4;
+pub const PROTOCOL: u32 = 5;
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 /// The commit this binary was built from (see `build.rs`), reported in `hello` for
 /// diagnosis and never compared; empty when unknown.

{teams_cli-0.2.3 → 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.3 → teams_cli-0.2.5}/src/desktop.rs

@@ -71,7 +71,11 @@ pub fn messaging_unsupported() -> AppError {
 }
 
 fn account_selection_error() -> AppError {
-    AppError::Desktop("Multiple Teams accounts are available; use `init --backend desktop --desktop-account personal` or `--desktop-account work-school` to select a surface. Multiple cached accounts within that surface are still unsupported".into())
+    AppError::Desktop("Both personal and work/school Teams are open; use `init --backend desktop --desktop-account personal` or `--desktop-account work-school` to select one".into())
+}
+
+fn cached_accounts_error() -> AppError {
+    AppError::Desktop("Teams holds cached data for more than one account, organization or display language, and Teams does not record which one is signed in. For a work/school account, Microsoft Graph works instead: `teams init --backend graph`".into())
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
@@ -676,6 +680,7 @@ fn people_result(reply: &Value, create: bool) -> Result<Value, AppError> {
     if let Some(code) = value["error"].as_str() {
         return Err(match code {
             "account_ambiguous" => account_selection_error(),
+            "cache_ambiguous" => cached_accounts_error(),
             "permission_denied" => AppError::Permission("Teams policy does not allow a chat with this recipient".into()),
             "search_failed" => AppError::Desktop("Teams could not resolve this person. Check sign-in and try their full email address".into()),
             "layout" => AppError::Unsupported("This Teams version does not expose a supported recipient interface".into()),
@@ -784,6 +789,7 @@ fn send_error(code: &str) -> AppError {
     match code {
         "not_found" => AppError::NotFound("chat not found in the Teams desktop cache".into()),
         "account_ambiguous" => account_selection_error(),
+        "cache_ambiguous" => cached_accounts_error(),
         "unconfirmed" => AppError::Unconfirmed(
             "Teams did not confirm the message; it may still be delivered. Check the chat before sending again".into(),
         ),
@@ -894,6 +900,9 @@ fn read_page(reply: &Value) -> Result<Page, AppError> {
         if code == "account_ambiguous" {
             return Err(account_selection_error());
         }
+        if code == "cache_ambiguous" {
+            return Err(cached_accounts_error());
+        }
         return Err(AppError::Desktop(match (status, code) {
             (Some(status), _) => status.detail().into(),
             (None, "no_target") => {
@@ -928,6 +937,9 @@ fn read_page(reply: &Value) -> Result<Page, AppError> {
     if value["error"] == "account_ambiguous" {
         return Err(account_selection_error());
     }
+    if value["error"] == "cache_ambiguous" {
+        return Err(cached_accounts_error());
+    }
     let items = value["items"].as_array().ok_or_else(invalid)?.clone();
     let next_cursor = match &value["next"] {
         Value::Null => None,
@@ -1219,7 +1231,7 @@ mod tests {
     /// the new one; otherwise just update the expectations.
     #[test]
     fn the_protocol_is_pinned() {
-        assert_eq!(helper::PROTOCOL, 4);
+        assert_eq!(helper::PROTOCOL, 5);
         let cursor = encode_cursor(&json!({"t": 1, "id": "m1"})).unwrap();
         assert_eq!(
             read_request(9222, Some(NOTES), 20, Some(&cursor)).unwrap(),
@@ -1258,14 +1270,15 @@ mod tests {
                 .map(|b| format!("{b:02x}"))
                 .collect::<String>()
         });
-        // Protocol 4 adds recipient operations; existing sends retain their request shapes.
+        // 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",
-                "3e837cc21336",
-                "3d628a24b464"
+                "7d2b70751d6a",
+                "23b1a0e4b293"
             ]
         );
     }
@@ -1300,7 +1313,11 @@ mod tests {
         ));
         assert!(matches!(
             people_result(&page_reply(json!({"error":"account_ambiguous"})), false),
-            Err(AppError::Desktop(_))
+            Err(AppError::Desktop(m)) if m.contains("--desktop-account")
+        ));
+        assert!(matches!(
+            people_result(&page_reply(json!({"error":"cache_ambiguous"})), false),
+            Err(AppError::Desktop(m)) if !m.contains("--desktop-account")
         ));
         for id in [
             "someone@example.invalid",
@@ -1469,6 +1486,7 @@ mod tests {
             Err(AppError::NotFound(_))
         ));
         let layout = json!({"result":{"exceptionDetails":{"exception":{"description":"Error: layout\n    at x"}}}});
+        // Mixed personal and work/school windows are resolved by choosing a surface.
         for ambiguous in [
             json!({"error": "account_ambiguous"}),
             reply(json!({"error": "account_ambiguous"})),
@@ -1480,6 +1498,20 @@ mod tests {
                 matches!(sent_message(&ambiguous, CHAT), Err(AppError::Desktop(m)) if m.contains("--desktop-account"))
             );
         }
+        // Several caches within one surface are not, so no flag is suggested.
+        for ambiguous in [
+            json!({"error": "cache_ambiguous"}),
+            reply(json!({"error": "cache_ambiguous"})),
+        ] {
+            for result in [
+                read_page(&ambiguous).map(|_| ()),
+                sent_message(&ambiguous, CHAT).map(|_| ()),
+            ] {
+                assert!(
+                    matches!(result, Err(AppError::Desktop(m)) if m.contains("cached") && !m.contains("--desktop-account"))
+                );
+            }
+        }
         assert!(matches!(read_page(&layout), Err(AppError::Desktop(m)) if m.contains("layout")));
         for reply in [
             json!({"error": "no_target"}),

teams_cli-0.2.5/src/desktop_cache.js

@@ -0,0 +1,48 @@
+// Select one account's cache databases. Several account caches can coexist in a
+// storage context; their records must never be joined or sent through arbitrarily.
+all => {
+  const candidates = kind => all.filter(db =>
+    typeof db.name === 'string' && db.name.includes(':' + kind + ':'));
+  // Teams names caches `<prefix>:<kind>:<client>:<tenant>:<user>:<locale>`. Other
+  // accounts, guest organizations and earlier display languages leave their own; the
+  // signed-in one is what Teams itself records, and anything less agreed is refused.
+  const signedIn = () => {
+    try {
+      const item = key => JSON.parse(localStorage.getItem(key) ?? 'null');
+      const user = item('tmp.auth.v1.GLOBAL.PrimaryUserId.PrimaryUserId')?.item;
+      const primary = item('tmp.react-web-client.cachedPrimaryUser');
+      if (typeof user !== 'string' || primary?.userId !== user || typeof primary.tenantId !== 'string') return null;
+      const locale = localStorage.getItem(`tmp.${primary.tenantId}.${user}.react-web-client.applicationLocaleCode`);
+      return { tenant: primary.tenantId, user, locale };
+    } catch {
+      return null;
+    }
+  };
+  let conversations = candidates('conversation-manager');
+  if (conversations.length > 1) {
+    const active = signedIn();
+    const part = (db, index) => db.name.split(':')[index];
+    if (active) conversations = conversations.filter(db =>
+      part(db, 3) === active.tenant && part(db, 4) === active.user);
+    if (active && conversations.length > 1) conversations = conversations.filter(db => part(db, 5) === active.locale);
+    if (conversations.length !== 1) return { error: 'cache_ambiguous' };
+  }
+  if (conversations.length !== 1) return { error: 'layout' };
+  const conversation = conversations[0].name;
+  const [, , , tenant, account] = conversation.split(':');
+  if (!account) return { error: 'layout' };
+  const related = kind => {
+    const sibling = conversation.replace(':conversation-manager:', ':' + kind + ':');
+    if (all.some(db => db.name === sibling)) return sibling;
+    const matches = candidates(kind).filter(db => db.name.split(':')[4] === account);
+    return matches.length === 1 ? matches[0].name : null;
+  };
+  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.3 → teams_cli-0.2.5}/src/desktop_people.js

@@ -281,7 +281,7 @@ async (p, select) => {
   } finally {
     db?.close();
   }
-  if (own.length !== 1) return { error: own.length ? "account_ambiguous" : "layout" };
+  if (own.length !== 1) return { error: own.length ? "cache_ambiguous" : "layout" };
   if (own[0] === p.recipient) return {id:"48:notes",chatType:"oneOnOne",members:[{userId:own[0]}],source:"desktop"};
   const userIds = [...new Set([own[0], p.recipient])];
   const lookup = operationDoc(

{teams_cli-0.2.3 → 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.3 → 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,16 +232,109 @@ 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/);
   assert.ok(f.opened.every(database => database.endsWith(':account-a')));
 });
 
+function selectWith(names, storage = {}) {
+  const context = vm.createContext({ localStorage: { getItem: key => key in storage ? storage[key] : null } });
+  // Compare plain values: objects from another context have their own prototypes.
+  return JSON.parse(JSON.stringify(vm.runInContext(source('desktop_cache.js'), context)(names.map(name => ({ name })))));
+}
+
+const teams = (kind, tenant, user, locale = 'en-us') => `Teams:${kind}:react-web-client:${tenant}:${user}:${locale}`;
+const signedIn = (tenant, user, locale) => ({
+  'tmp.auth.v1.GLOBAL.PrimaryUserId.PrimaryUserId': JSON.stringify({ item: user }),
+  'tmp.react-web-client.cachedPrimaryUser': JSON.stringify({ tenantId: tenant, userId: user }),
+  ...(locale && { [`tmp.${tenant}.${user}.react-web-client.applicationLocaleCode`]: locale }),
+});
+const caches = (tenant, user, locale) => ['conversation-manager', 'replychain-manager', 'profiles']
+  .map(kind => teams(kind, tenant, user, locale));
+
+test('the signed-in user, tenant and display language select among coexisting caches', () => {
+  const names = [
+    ...caches('home', 'me', 'en-us'), ...caches('home', 'me', 'nl-nl'),
+    ...caches('guest', 'me-as-guest'), ...caches('home', 'colleague'),
+  ];
+  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.
+  assert.equal(selectWith(names, signedIn('home', 'colleague')).conversation, teams('conversation-manager', 'home', 'colleague'));
+});
+
+test('caches are refused when Teams does not identify exactly one of them', () => {
+  const names = [...caches('home', 'me', 'en-us'), ...caches('home', 'me', 'nl-nl'), ...caches('home', 'colleague')];
+  const inconsistent = { ...signedIn('home', 'me', 'en-us'),
+    'tmp.react-web-client.cachedPrimaryUser': JSON.stringify({ tenantId: 'home', userId: 'colleague' }) };
+  for (const storage of [{}, signedIn('home', 'me'), signedIn('home', 'me', 'de-de'), signedIn('home', 'stranger', 'en-us'), inconsistent,
+    { 'tmp.auth.v1.GLOBAL.PrimaryUserId.PrimaryUserId': 'not json' }]) {
+    assert.deepEqual(selectWith(names, storage), { error: 'cache_ambiguous' });
+  }
+});
+
 test('ambiguous account caches are refused before reading or sending', async () => {
   const f = fixture({ ambiguous: true });
-  assert.equal((await f.read()).error, 'account_ambiguous');
-  assert.equal((await f.send()).error, 'account_ambiguous');
+  assert.equal((await f.read()).error, 'cache_ambiguous');
+  assert.equal((await f.send()).error, 'cache_ambiguous');
   assert.deepEqual(f.opened, []);
   assert.deepEqual(f.mutations, []);
 });

teams_cli-0.2.3/src/desktop_cache.js

@@ -1,17 +0,0 @@
-// Select one account's cache databases. Several account caches can coexist in a
-// storage context; their records must never be joined or sent through arbitrarily.
-all => {
-  const candidates = kind => all.filter(db =>
-    typeof db.name === 'string' && db.name.includes(':' + kind + ':'));
-  const conversations = candidates('conversation-manager');
-  if (conversations.length > 1) return { error: 'account_ambiguous' };
-  if (conversations.length !== 1) return { error: 'layout' };
-  const conversation = conversations[0].name;
-  const account = conversation.split(':')[4];
-  if (!account) return { error: 'layout' };
-  const related = kind => {
-    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') };
-}