@rikaidev/yomi 0.4.2 → 0.5.0

package/README.md

@@ -479,6 +479,11 @@ fake success.
 this device a sign-in prompt — this is the single most common reason a first login
 appears to hang.
 
+> **⚠️ Single Desktop Session Limit:** LINE allows only **one desktop client session at a time**
+> per account. Because Yomi connects as a desktop secondary device (`DESKTOPMAC`), logging into Yomi
+> will sign out your official LINE Desktop app (and signing back into LINE Desktop will invalidate
+> Yomi's session). You cannot use Yomi and the official LINE Desktop client simultaneously.
+
 You only need to give the agent your phone number in E.164 form — it supplies the
 region itself (e.g. `TW` for a `+886` number) when it calls the tool.
 
@@ -516,16 +521,16 @@ entirely**.
 ### Sessions and credentials
 
 Yomi owns its own login. On startup it calls `resumeSession()` once, reading the
-LINE session from the macOS Keychain (service `com.yomi.credentials`, account
+LINE session from the macOS Keychain (service `dev.rikai.yomi.credentials`, account
 `line`) and silently refreshing the token if needed.
 
 - **First-party credentials.** The passwordless login persists the auth token,
   refresh token, certificate, MID, and the E2EE keypair itself — then reads them
   back to verify the write actually landed. A login that can't be persisted fails
   loudly at login, not silently at the next restart.
-- **Backward compatibility.** If no session is found under `com.yomi.credentials`,
-  Yomi reads the legacy `com.inboxd.credentials` entry once, migrates it forward,
-  and never deletes it. An existing session keeps working with no re-login.
+- **Shared session.** The session is stored in the canonical `dev.rikai.yomi.credentials`
+  keychain entry (or local credential store), allowing Yomi MCP and Yomi Desktop to
+  share the exact same LINE login session seamlessly.
 - **Platform note.** On macOS the session lives in the login Keychain. On **Linux
   and Windows** Yomi currently falls back to a local JSON file — functional, but
   less protected than an OS secret store, and less exercised than the macOS path.
@@ -590,6 +595,15 @@ Yomi runs as a **secondary device** on your account. That shapes what it can see
   per-epoch group keys, not a bug here. It can also cut sideways: the epoch your phone
   holds and the epoch Yomi holds need not be the same, so the **two devices can each
   read a different slice** of the very same group.
+- **Installing Yomi does not itself rotate anything, so "before I installed Yomi" is
+  the wrong boundary.** Yomi only ever *resolves* an existing group key; it never
+  registers (mints) one, because minting rotates the group's shared secret for every
+  member and strands every message encrypted under the previous one. So a fresh install
+  picks up the **current** key and reads back to the last rotation — which may predate
+  the install by months. The boundary is the last rekey, not your install date. And
+  once Yomi has seen an epoch it keeps that key, so a rotation *after* install leaves
+  it able to read both sides. If a group comes back undecryptable all the way to
+  **today**, that is not this limitation — please report it.
 - **1:1 media** uses the account-level E2EE keychain, which a secondary device fully
   possesses (LINE syncs it during pairing) — Yomi **can** decrypt 1:1 images/files it
   can see.

package/dist/attention/policy.js

@@ -0,0 +1,95 @@
+import { getDefaultEmbedder } from '../search/default-embedder.js';
+// Natural-language intent descriptions, not trigger-word lists. The local
+// transformer embeds both descriptions and messages; vector similarity does
+// the classification even when no words literally overlap.
+const INTENT_ANCHORS = {
+    reply: [
+        '對方直接向我提出問題、請求協助或要求我做決定，正在等待我的答覆',
+        '工作交辦或需要我採取具體行動並回覆結果',
+    ],
+    deadline: [
+        '有明確期限、會議時間、預約或即將到期的工作，需要及時處理',
+        '緊急事故、風險或延誤，若不處理會造成後果',
+    ],
+    transaction: [
+        '與我有關的帳單、付款、訂單、物流、航班、預約或帳號安全狀態異常',
+        '交易失敗、行程變更或服務中斷，需要本人確認',
+    ],
+    important: [
+        '與目前工作或生活直接相關的重要進度與公告，值得本人閱讀但不必回覆',
+        '關鍵人物提供需要掌握的決策背景或狀態更新',
+    ],
+    ordinary: [
+        '一般聊天、問候、貼圖、轉傳或沒有下一步的日常資訊',
+        '內容與本人沒有直接關係，也不需要採取行動',
+    ],
+    promotion: [
+        '品牌官方帳號寄送的行銷廣告、優惠活動、導購內容或宣傳文案',
+        '用吸引人的疑問句包裝促銷活動，但並非真的在等待本人回答',
+    ],
+};
+function dot(a, b) {
+    let value = 0;
+    for (let i = 0; i < Math.min(a.length, b.length); i++)
+        value += a[i] * b[i];
+    return value;
+}
+/** Transformer-embedding semantic classification followed only by explicit
+ * product controls such as mute, mention and manual priority. */
+export async function scoreAttentionBatch(inputs, embedder = getDefaultEmbedder()) {
+    if (inputs.length === 0)
+        return [];
+    const intents = Object.keys(INTENT_ANCHORS);
+    const anchors = intents.flatMap((intent) => INTENT_ANCHORS[intent].map((text) => ({ intent, text })));
+    const vectors = await embedder.embed([
+        ...anchors.map((anchor) => anchor.text),
+        ...inputs.map((input) => input.text || '無文字訊息'),
+    ]);
+    const anchorVectors = vectors.slice(0, anchors.length);
+    const messageVectors = vectors.slice(anchors.length);
+    return inputs.map((input, inputIndex) => {
+        if (input.isMuted)
+            return { score: -100, tier: 'filtered', reason: '已靜音' };
+        if (input.explicitPriority)
+            return { score: 70, tier: 'now', reason: '使用者標記優先' };
+        if (input.hasMention)
+            return { score: 65, tier: 'now', reason: '直接提及你' };
+        const similarities = new Map();
+        anchors.forEach((anchor, anchorIndex) => {
+            const similarity = dot(messageVectors[inputIndex], anchorVectors[anchorIndex]);
+            similarities.set(anchor.intent, Math.max(similarities.get(anchor.intent) ?? -Infinity, similarity));
+        });
+        const ranked = [...intents].sort((a, b) => (similarities.get(b) ?? 0) - (similarities.get(a) ?? 0));
+        let intent = ranked[0];
+        // Broadcast accounts commonly announce dated events and use rhetorical
+        // questions. Only a transaction/account/service state tied to the user may
+        // elevate them; generic events are not the user's deadline.
+        if (input.isOfficial && intent !== 'transaction')
+            intent = 'promotion';
+        const scoreByIntent = {
+            reply: 55,
+            deadline: 60,
+            transaction: 50,
+            important: 25,
+            ordinary: 0,
+            promotion: -40,
+        };
+        const score = scoreByIntent[intent] + (input.unreadCount > 0 ? 5 : 0);
+        const tier = score >= 55
+            ? 'now'
+            : score >= 35
+                ? 'today'
+                : score >= 20
+                    ? 'know'
+                    : 'filtered';
+        const reasons = {
+            reply: '對方可能在等你回覆',
+            deadline: '有期限、行程或緊急事項',
+            transaction: '與你的交易或服務狀態有關',
+            important: '重要資訊，但不需立即回覆',
+            ordinary: '一般資訊，沒有明確下一步',
+            promotion: '官方宣傳或與你較無關',
+        };
+        return { score, tier, reason: reasons[intent] };
+    });
+}

package/dist/auth/credential-store.js

@@ -13,9 +13,8 @@
  * rotated auth token during `resumeSession`), not only by a direct login.
  *
  * Keychain account: namespace (e.g. 'line')
- * KeychainService service name: see keychain.ts — writes go to Yomi's own
- * canonical namespace; a legacy namespace from before this split is read
- * as a fallback and migrated forward, never written to or deleted.
+ * KeychainService service name: see keychain.ts — stored in Yomi's canonical
+ * namespace (`dev.rikai.yomi.credentials`), shared across Yomi MCP and Yomi Desktop.
  *
  * The Keychain is machine-global: it is NOT scoped by YOMI_DATA_DIR, so on
  * macOS an automated run that only redirected the data dir would still find —
@@ -197,8 +196,13 @@ export class CredentialStore {
         this.filePath = fallbackFilePath;
         this.cache = new Map();
         this.loaded = false;
+        // Desktop background bridges are deliberately read-only.  They must use
+        // the user-isolated credential file and never invoke `security` to mutate
+        // the Keychain during a 15s poll (which causes repeated macOS prompts).
         this.secureStorageEnabled =
-            process.platform === 'darwin' && process.env.YOMI_NO_KEYCHAIN !== '1';
+            process.platform === 'darwin' &&
+                process.env.YOMI_NO_KEYCHAIN !== '1' &&
+                process.env.YOMI_READ_ONLY_SESSION !== '1';
         this.keychainService = this.secureStorageEnabled
             ? getKeychainService()
             : null;
@@ -217,20 +221,31 @@ export class CredentialStore {
      * @returns Serialized credential blob or null when missing.
      */
     async readPersistedBlob() {
+        try {
+            const fs = await import('node:fs/promises');
+            const fileData = await fs.readFile(this.filePath, 'utf-8');
+            if (fileData?.trim()) {
+                return fileData;
+            }
+        }
+        catch { }
         if (this.secureStorageEnabled && this.keychainService) {
             const result = await this.keychainService.getCredential(this.keychainAccount);
             if (result.success && result.password) {
+                try {
+                    const fs = await import('node:fs/promises');
+                    await fs.mkdir(dirname(this.filePath), {
+                        recursive: true,
+                        mode: 0o700,
+                    });
+                    await fs.writeFile(this.filePath, result.password, { mode: 0o600 });
+                }
+                catch { }
                 return result.password;
             }
             return null;
         }
-        try {
-            const fs = await import('node:fs/promises');
-            return await fs.readFile(this.filePath, 'utf-8');
-        }
-        catch {
-            return null;
-        }
+        return null;
     }
     /**
      * Load all credentials into cache from keychain or file.
@@ -263,6 +278,12 @@ export class CredentialStore {
         }
         if (this.secureStorageEnabled && this.keychainService) {
             await this.keychainService.setCredential(this.keychainAccount, blob);
+            try {
+                const fs = await import('node:fs/promises');
+                await fs.mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
+                await fs.writeFile(this.filePath, blob, { mode: 0o600 });
+            }
+            catch { }
             this.lastPersistedBlob = blob;
             return;
         }

package/dist/auth/keychain.js

@@ -8,20 +8,12 @@
 import { spawn } from 'node:child_process';
 import { createCliLogger } from '../util/log.js';
 /**
- * Yomi's own Keychain service name. Yomi performs a first-party
+ * Yomi's Keychain service name. Yomi performs a first-party
  * passwordless LINE login (see the `login` MCP tool) and persists the
  * resulting session here — auth token, certificate, refresh token, mid,
- * and the E2EE NaCl keypair. All writes go through this namespace only.
+ * and the E2EE NaCl keypair. Shared between Yomi MCP and Yomi Desktop.
  */
-const SERVICE_NAME = 'com.yomi.credentials';
-/**
- * Legacy keychain service name, read-only. Predates Yomi owning its own
- * credentials; kept solely so a live session created before this split
- * keeps working without forcing the operator through a phone-PIN
- * re-login. Entries here are read and migrated forward into
- * `SERVICE_NAME`, never written to and never deleted.
- */
-const LEGACY_SERVICE_NAME = 'com.inboxd.credentials';
+const SERVICE_NAME = 'dev.rikai.yomi.credentials';
 const authLog = createCliLogger('AUTH');
 /**
  * Wrapper for macOS `security` keychain CLI commands.
@@ -49,6 +41,7 @@ class KeychainCommands {
                 '-w',
                 password,
                 '-U',
+                '-A',
             ]);
             let stderr = '';
             child.stderr.on('data', (data) => {
@@ -166,20 +159,12 @@ class KeychainCommands {
 /**
  * Service for managing macOS Keychain credentials.
  *
- * Reads try the canonical namespace first, then fall back to the legacy
- * namespace and migrate a hit forward. Writes and deletes only ever touch
- * the canonical namespace — the legacy entry is never deleted.
+ * Direct reads, writes, and deletes on the canonical Yomi namespace.
  */
 export class KeychainService {
     commands;
-    legacyCommands;
-    // Accounts whose canonical entry this process has already seen (read or
-    // written). Once seen, a later read miss is treated as transient and must
-    // NOT fall back to the legacy namespace — see getCredential.
-    canonicalSeen = new Set();
     constructor() {
         this.commands = new KeychainCommands(SERVICE_NAME);
-        this.legacyCommands = new KeychainCommands(LEGACY_SERVICE_NAME);
     }
     /**
      * Stores a credential in Keychain.
@@ -189,52 +174,20 @@ export class KeychainService {
      * @returns Promise resolving to credential result.
      */
     async setCredential(account, password) {
-        // `add-generic-password -U` updates the item in place when it exists, so
-        // this is a single atomic keychain op. Do NOT delete-then-add: that leaves
-        // a window where the entry is absent, during which a concurrent read falls
-        // through to the legacy namespace and resurrects stale credentials over the
-        // current ones (the root of the "session silently logged out" bug).
-        const result = await this.commands.set(account, password);
-        if (result.success) {
-            this.canonicalSeen.add(account);
-        }
-        return result;
+        return await this.commands.set(account, password);
     }
     /**
      * Retrieves a credential from Keychain.
      *
-     * Tries the canonical namespace first. Only if this process has NEVER seen
-     * the canonical entry does it fall back to the legacy namespace and migrate a
-     * hit forward (one-time). Once the canonical entry has been seen, a later
-     * miss is transient (item mid-update) and returns the miss as-is rather than
-     * resurrecting a stale legacy copy on top of the live session.
-     *
      * @param account - Account name.
      * @returns Promise resolving to credential result.
      */
     async getCredential(account) {
-        const primary = await this.commands.get(account);
-        if (primary.success) {
-            this.canonicalSeen.add(account);
-            return primary;
-        }
-        if (this.canonicalSeen.has(account)) {
-            return primary;
-        }
-        const legacy = await this.legacyCommands.get(account);
-        if (legacy.success && legacy.password) {
-            await this.commands.set(account, legacy.password);
-            this.canonicalSeen.add(account);
-            authLog.info('keychain.migrated_from_legacy', { account });
-        }
-        return legacy;
+        return await this.commands.get(account);
     }
     /**
      * Deletes a credential from Keychain.
      *
-     * Operates on the canonical namespace only. The legacy namespace is
-     * never deleted, even here.
-     *
      * @param account - Account name.
      * @returns Promise resolving to credential result.
      */