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

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

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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.4}/Cargo.lock

@@ -3187,7 +3187,7 @@ dependencies = [
 
 [[package]]
 name = "teams-cli"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "assert_cmd",
  "base64 0.23.1",

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

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

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

{teams_cli-0.2.3 → teams_cli-0.2.4}/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.4}/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.4}/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,14 @@ 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.
         assert_eq!(
             scripts,
             [
                 "32ca0293d2d5",
                 "baa0bc29c44b",
-                "3e837cc21336",
-                "3d628a24b464"
+                "025a8edc46b8",
+                "23b1a0e4b293"
             ]
         );
     }
@@ -1300,7 +1312,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 +1485,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 +1497,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.4/src/desktop_cache.js

@@ -0,0 +1,41 @@
+// 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 account = conversation.split(':')[4];
+  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;
+  };
+  return { account, conversation, replies: related('replychain-manager'), profiles: related('profiles') };
+}

{teams_cli-0.2.3 → teams_cli-0.2.4}/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.4}/tests/desktop_scripts.test.cjs

@@ -231,10 +231,50 @@ test('a missing account database never falls back to another account', async ()
   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] of [['home', 'me', 'nl-nl'], ['home', 'me', 'en-us'], ['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 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') };
-}