@jackwener/opencli 0.4.2 → 0.4.4

package/src/clis/twitter/notifications.ts

@@ -0,0 +1,119 @@
+import { cli, Strategy } from '../../registry.js';
+import * as fs from 'fs';
+
+cli({
+  site: 'twitter',
+  name: 'notifications',
+  description: 'Get Twitter/X notifications',
+  domain: 'x.com',
+  strategy: Strategy.INTERCEPT,
+  browser: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20 },
+  ],
+  columns: ['id', 'action', 'author', 'text', 'url'],
+  func: async (page, kwargs) => {
+    // 1. Navigate to notifications
+    await page.goto('https://x.com/notifications');
+    await page.wait(5);
+
+    // 2. Inject interceptor
+    await page.installInterceptor('NotificationsTimeline');
+
+    // 3. Trigger API by scrolling (if we need to load more)
+    await page.autoScroll({ times: 2, delayMs: 2000 });
+
+    // 4. Retrieve data
+    const requests = await page.getInterceptedRequests();
+    if (!requests || requests.length === 0) return [];
+
+    let results: any[] = [];
+    for (const req of requests) {
+      try {
+        let instructions = [];
+        if (req.data?.data?.viewer?.timeline_response?.timeline?.instructions) {
+             instructions = req.data.data.viewer.timeline_response.timeline.instructions;
+        } else if (req.data?.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
+             instructions = req.data.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
+        } else if (req.data?.data?.timeline?.instructions) {
+             instructions = req.data.data.timeline.instructions;
+        }
+
+        let addEntries = instructions.find((i: any) => i.type === 'TimelineAddEntries');
+        
+        // Sometimes it's the first object without a 'type' field but has 'entries'
+        if (!addEntries) {
+             addEntries = instructions.find((i: any) => i.entries && Array.isArray(i.entries));
+        }
+        
+        if (!addEntries) continue;
+
+        for (const entry of addEntries.entries) {
+          if (!entry.entryId.startsWith('notification-')) {
+             if (entry.content?.items) {
+                 for (const subItem of entry.content.items) {
+                     processNotificationItem(subItem.item?.itemContent, subItem.entryId);
+                 }
+             }
+             continue;
+          }
+
+          processNotificationItem(entry.content?.itemContent, entry.entryId);
+        }
+
+        function processNotificationItem(itemContent: any, entryId: string) {
+            if (!itemContent) return;
+            
+            // Twitter wraps standard notifications 
+            let item = itemContent?.notification_results?.result || itemContent?.tweet_results?.result || itemContent;
+
+            let actionText = 'Notification';
+            let author = 'unknown';
+            let text = '';
+            let urlStr = '';
+            
+            if (item.__typename === 'TimelineNotification') {
+                 // Greet likes, retweet, mentions
+                 text = item.rich_message?.text || item.message?.text || '';
+                 author = item.template?.from_users?.[0]?.user_results?.result?.core?.screen_name || 'unknown';
+                 urlStr = item.notification_url?.url || '';
+                 actionText = item.notification_icon || 'Activity';
+                 
+                 // If there's an attached tweet
+                 const targetTweet = item.template?.target_objects?.[0]?.tweet_results?.result;
+                 if (targetTweet) {
+                    text += ' | ' + (targetTweet.legacy?.full_text || '');
+                    if (!urlStr) {
+                         urlStr = `https://x.com/i/status/${targetTweet.rest_id}`;
+                    }
+                 }
+            } else if (item.__typename === 'TweetNotification') {
+                 // Direct mention/reply
+                 const tweet = item.tweet_result?.result;
+                 author = tweet?.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                 text = tweet?.legacy?.full_text || item.message?.text || '';
+                 actionText = 'Mention/Reply';
+                 urlStr = `https://x.com/i/status/${tweet?.rest_id}`;
+            } else if (item.__typename === 'Tweet') {
+                 author = item.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                 text = item.legacy?.full_text || '';
+                 actionText = 'Mention';
+                 urlStr = `https://x.com/i/status/${item.rest_id}`;
+            }
+
+            results.push({
+              id: item.id || item.rest_id || entryId,
+              action: actionText,
+              author: author,
+              text: text,
+              url: urlStr || `https://x.com/notifications`
+            });
+        }
+      } catch (e) {
+        // ignore parsing errors for individual payloads
+      }
+    }
+
+    return results.slice(0, kwargs.limit);
+  }
+});

package/src/clis/twitter/post.ts

@@ -0,0 +1,68 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'post',
+  description: 'Post a new tweet/thread',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'text', type: 'string', required: true, help: 'The text content of the tweet' },
+  ],
+  columns: ['status', 'message', 'text'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    // 1. Navigate directly to the compose tweet modal
+    await page.goto('https://x.com/compose/tweet');
+    await page.wait(3); // Wait for the modal and React app to hydrate
+
+    // 2. Automate typing and clicking
+    const result = await page.evaluate(`(async () => {
+        try {
+            // Find the active text area
+            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+            if (box) {
+                box.focus();
+                // insertText is the most reliable way to trigger React's onChange events
+                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
+            } else {
+                return { ok: false, message: 'Could not find the tweet composer text area.' };
+            }
+            
+            // Wait a brief moment for the button state to update
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Click the post button
+            const btn = document.querySelector('[data-testid="tweetButton"]');
+            if (btn && !btn.disabled) {
+                btn.click();
+                return { ok: true, message: 'Tweet posted successfully.' };
+            } else {
+                // Sometimes it's rendered inline depending on the viewport
+                const inlineBtn = document.querySelector('[data-testid="tweetButtonInline"]');
+                if (inlineBtn && !inlineBtn.disabled) {
+                    inlineBtn.click();
+                    return { ok: true, message: 'Tweet posted successfully.' };
+                }
+                return { ok: false, message: 'Tweet button is disabled or not found.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+
+    // 3. Wait a few seconds for the network request to finish sending
+    if (result.ok) {
+        await page.wait(3);
+    }
+
+    return [{
+        status: result.ok ? 'success' : 'failed',
+        message: result.message,
+        text: kwargs.text
+    }];
+  }
+});

package/src/clis/twitter/reply.ts

@@ -0,0 +1,62 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'reply',
+  description: 'Reply to a specific tweet',
+  domain: 'x.com',
+  strategy: Strategy.UI, // Uses the UI directly to input and click post
+  browser: true,
+  args: [
+    { name: 'url', type: 'string', required: true, help: 'The URL of the tweet to reply to' },
+    { name: 'text', type: 'string', required: true, help: 'The text content of your reply' },
+  ],
+  columns: ['status', 'message', 'text'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    // 1. Navigate to the tweet page
+    await page.goto(kwargs.url);
+    await page.wait(5); // Wait for the react application to hydrate
+
+    // 2. Automate typing the reply and clicking reply
+    const result = await page.evaluate(`(async () => {
+        try {
+            // Find the reply text area on the tweet page. 
+            // The placeholder is usually "Post your reply"
+            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+            if (box) {
+                box.focus();
+                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
+            } else {
+                return { ok: false, message: 'Could not find the reply text area. Are you logged in?' };
+            }
+            
+            // Wait for React state to register the input and enable the button
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Find the Reply button. It usually shares the same test id tweetButtonInline in this context
+            const btn = document.querySelector('[data-testid="tweetButtonInline"]');
+            if (btn && !btn.disabled) {
+                btn.click();
+                return { ok: true, message: 'Reply posted successfully.' };
+            } else {
+                return { ok: false, message: 'Reply button is disabled or not found.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+
+    if (result.ok) {
+        await page.wait(3); // Wait for network submission to complete
+    }
+
+    return [{
+        status: result.ok ? 'success' : 'failed',
+        message: result.message,
+        text: kwargs.text
+    }];
+  }
+});

package/src/clis/v2ex/daily.ts

@@ -0,0 +1,105 @@
+/**
+ * V2EX Daily Check-in adapter.
+ */
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'v2ex',
+  name: 'daily',
+  description: 'V2EX 每日签到并领取铜币',
+  domain: 'www.v2ex.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  forceExtension: true,
+  args: [],
+  columns: ['status', 'message'],
+  func: async (page: IPage | null) => {
+    if (!page) throw new Error('Browser page required');
+
+    if (process.env.OPENCLI_VERBOSE) {
+      console.error('[opencli:v2ex] Navigating to /mission/daily');
+    }
+    await page.goto('https://www.v2ex.com/mission/daily');
+    
+    // Cloudflare challenge bypass wait
+    for (let i = 0; i < 5; i++) {
+      await new Promise(r => setTimeout(r, 1500));
+      const title = await page.evaluate(`() => document.title`);
+      if (!title?.includes('Just a moment')) break;
+      if (process.env.OPENCLI_VERBOSE) console.error('[opencli:v2ex] Waiting for Cloudflare...');
+    }
+
+    // Evaluate DOM to find if we need to check in
+    const checkResult = await page.evaluate(`
+      async () => {
+        const btn = document.querySelector('input.super.normal.button');
+        if (!btn || !btn.value.includes('领取')) {
+          return { claimed: true, message: '今日奖励已发/无需领取' };
+        }
+        
+        const onclick = btn.getAttribute('onclick');
+        if (onclick) {
+          const match = onclick.match(/once=(\\d+)/);
+          if (match) {
+            return { claimed: false, once: match[1], message: btn.value };
+          }
+        }
+        
+        return { 
+          claimed: false, 
+          error: '找到了按钮，但未能提取 once token',
+          debug_title: document.title,
+          debug_body: document.body.innerText.substring(0, 200).replace(/\\n/g, ' ')
+        };
+      }
+    `);
+
+    if (checkResult.error) {
+      if (process.env.OPENCLI_VERBOSE) {
+        console.error(`[opencli:v2ex:debug] Page Title: ${checkResult.debug_title}`);
+        console.error(`[opencli:v2ex:debug] Page Body: ${checkResult.debug_body}`);
+      }
+      throw new Error(checkResult.error);
+    }
+
+    if (checkResult.claimed) {
+      return [{ status: '✅ 已签到', message: checkResult.message }];
+    }
+
+    // Perform check in
+    if (process.env.OPENCLI_VERBOSE) {
+      console.error(`[opencli:v2ex] Found check-in token: once=${checkResult.once}. Checking in...`);
+    }
+    
+    await page.goto(`https://www.v2ex.com/mission/daily/redeem?once=${checkResult.once}`);
+    await new Promise(resolve => setTimeout(resolve, 3000)); // wait longer for redirect
+    
+    // Verify result
+    const verifyResult = await page.evaluate(`
+      async () => {
+        const btn = document.querySelector('input.super.normal.button');
+        if (!btn || !btn.value.includes('领取')) {
+          // fetch balance to show user
+          let balance = '';
+          const balanceLink = document.querySelector('a.balance_area');
+          if (balanceLink) {
+            balance = Array.from(balanceLink.childNodes)
+                           .filter(n => n.nodeType === 3)
+                           .map(n => n.textContent?.trim())
+                           .join(' ')
+                           .trim();
+          }
+          return { success: true, balance };
+        }
+        return { success: false };
+      }
+    `);
+
+    if (verifyResult.success) {
+      return [{ status: '🎉 签到成功', message: `当前余额: ${verifyResult.balance || '未知'}` }];
+    } else {
+      return [{ status: '❌ 签到失败', message: '未能确认签到结果，请手动检查' }];
+    }
+  },
+});

package/src/clis/v2ex/me.ts

@@ -0,0 +1,103 @@
+/**
+ * V2EX Me (Profile/Balance) adapter.
+ */
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'v2ex',
+  name: 'me',
+  description: 'V2EX 获取个人资料 (余额/未读提醒)',
+  domain: 'www.v2ex.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  forceExtension: true,
+  args: [],
+  columns: ['username', 'balance', 'unread_notifications', 'daily_reward_ready'],
+  func: async (page: IPage | null) => {
+    if (!page) throw new Error('Browser page required');
+
+    if (process.env.OPENCLI_VERBOSE) {
+      console.error('[opencli:v2ex] Navigating to /');
+    }
+    await page.goto('https://www.v2ex.com/');
+    
+    // Cloudflare challenge bypass wait
+    for (let i = 0; i < 5; i++) {
+      await new Promise(r => setTimeout(r, 1500));
+      const title = await page.evaluate(`() => document.title`);
+      if (!title?.includes('Just a moment')) break;
+      if (process.env.OPENCLI_VERBOSE) console.error('[opencli:v2ex] Waiting for Cloudflare...');
+    }
+    
+    // Evaluate DOM to extract user profile
+    const data = await page.evaluate(`
+      async () => {
+        let username = 'Unknown';
+        const navLinks = Array.from(document.querySelectorAll('a.top')).map(a => a.textContent?.trim());
+        if (navLinks.length > 1 && navLinks[0] === '首页') {
+          username = navLinks[1] || 'Unknown';
+        }
+        
+        if (username === 'Unknown') {
+          // Fallback check just in case
+          const profileEl = document.querySelector('a[href^="/member/"]');
+          if (profileEl && profileEl.textContent && profileEl.textContent.trim().length > 0) {
+            username = profileEl.textContent.trim();
+          }
+        }
+
+        let balance = '0';
+        const balanceLink = document.querySelector('a.balance_area');
+        if (balanceLink) {
+          balance = Array.from(balanceLink.childNodes)
+                         .filter(n => n.nodeType === 3)
+                         .map(n => n.textContent?.trim())
+                         .join(' ')
+                         .trim();
+        }
+
+        let unread_notifications = '0';
+        const notesEl = document.querySelector('a[href="/notifications"]');
+        if (notesEl) {
+          const text = notesEl.textContent?.trim() || '';
+          const match = text.match(/(\\d+)\\s*未读提醒/);
+          if (match) {
+            unread_notifications = match[1];
+          }
+        }
+
+        let daily_reward_ready = false;
+        const dailyEl = document.querySelector('a[href^="/mission/daily"]');
+        if (dailyEl && dailyEl.textContent?.includes('领取今日的登录奖励')) {
+          daily_reward_ready = true;
+        }
+
+        if (username === 'Unknown') {
+          return { 
+            error: '请先登录 V2EX（可能是 Cookie 未配置或已失效）',
+            debug_title: document.title,
+            debug_body: document.body.innerText.substring(0, 200).replace(/\\n/g, ' ')
+          };
+        }
+
+        return {
+          username,
+          balance,
+          unread_notifications,
+          daily_reward_ready: daily_reward_ready ? '是' : '否'
+        };
+      }
+    `);
+
+    if (data.error) {
+      if (process.env.OPENCLI_VERBOSE) {
+        console.error(`[opencli:v2ex:debug] Page Title: ${data.debug_title}`);
+        console.error(`[opencli:v2ex:debug] Page Body: ${data.debug_body}`);
+      }
+      throw new Error(data.error);
+    }
+
+    return [data];
+  },
+});

package/src/clis/v2ex/notifications.ts

@@ -0,0 +1,77 @@
+/**
+ * V2EX Notifications adapter.
+ */
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'v2ex',
+  name: 'notifications',
+  description: 'V2EX 获取提醒 (回复/由于)',
+  domain: 'www.v2ex.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  forceExtension: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of notifications' }
+  ],
+  columns: ['type', 'content', 'time'],
+  func: async (page: IPage | null, kwargs) => {
+    if (!page) throw new Error('Browser page required');
+
+    if (process.env.OPENCLI_VERBOSE) {
+      console.error('[opencli:v2ex] Navigating to /notifications');
+    }
+    await page.goto('https://www.v2ex.com/notifications');
+    await new Promise(r => setTimeout(r, 1500)); // waitForLoadState doesn't always work robustly
+    
+    // Evaluate DOM to extract notifications
+    const data = await page.evaluate(`
+      async () => {
+        const items = Array.from(document.querySelectorAll('#Main .box .cell[id^="n_"]'));
+        return items.map(item => {
+          let type = '通知';
+          let time = '';
+          
+          // determine type based on text content
+          const text = item.textContent || '';
+          if (text.includes('回复了你')) type = '回复';
+          else if (text.includes('感谢了你')) type = '感谢';
+          else if (text.includes('收藏了你')) type = '收藏';
+          else if (text.includes('提及你')) type = '提及';
+
+          const timeEl = item.querySelector('.snow');
+          if (timeEl) {
+            time = timeEl.textContent?.trim() || '';
+          }
+
+          // payload contains the actual reply text if any
+          let payload = '';
+          const payloadEl = item.querySelector('.payload');
+          if (payloadEl) {
+            payload = payloadEl.textContent?.trim() || '';
+          }
+
+          // fallback to full text cleaning if no payload (e.g. for favorites/thanks)
+          let content = payload;
+          if (!content) {
+            content = text.replace(/\\s+/g, ' ').trim();
+            // strip out time from content if present
+            if (time && content.includes(time)) {
+              content = content.replace(time, '').trim();
+            }
+          }
+
+          return { type, content, time };
+        });
+      }
+    `);
+
+    if (!Array.isArray(data)) {
+      throw new Error('Failed to parse notifications data');
+    }
+
+    const limit = kwargs.limit || 20;
+    return data.slice(0, limit);
+  },
+});

package/src/doctor.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest';
+import {
+  readTokenFromShellContent,
+  renderBrowserDoctorReport,
+  upsertShellToken,
+  readTomlConfigToken,
+  upsertTomlConfigToken,
+  upsertJsonConfigToken,
+} from './doctor.js';
+
+describe('shell token helpers', () => {
+  it('reads token from shell export', () => {
+    expect(readTokenFromShellContent('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"\n')).toBe('abc123');
+  });
+
+  it('appends token export when missing', () => {
+    const next = upsertShellToken('export PATH="/usr/bin"\n', 'abc123');
+    expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"');
+  });
+
+  it('replaces token export when present', () => {
+    const next = upsertShellToken('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="old"\n', 'new');
+    expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="new"');
+    expect(next).not.toContain('"old"');
+  });
+});
+
+describe('toml token helpers', () => {
+  it('reads token from playwright env section', () => {
+    const content = `
+[mcp_servers.playwright.env]
+PLAYWRIGHT_MCP_EXTENSION_TOKEN = "abc123"
+`;
+    expect(readTomlConfigToken(content)).toBe('abc123');
+  });
+
+  it('updates token inside existing env section', () => {
+    const content = `
+[mcp_servers.playwright.env]
+PLAYWRIGHT_MCP_EXTENSION_TOKEN = "old"
+`;
+    const next = upsertTomlConfigToken(content, 'new');
+    expect(next).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN = "new"');
+    expect(next).not.toContain('"old"');
+  });
+
+  it('creates env section when missing', () => {
+    const content = `
+[mcp_servers.playwright]
+type = "stdio"
+`;
+    const next = upsertTomlConfigToken(content, 'abc123');
+    expect(next).toContain('[mcp_servers.playwright.env]');
+    expect(next).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN = "abc123"');
+  });
+});
+
+describe('json token helpers', () => {
+  it('writes token into standard mcpServers config', () => {
+    const next = upsertJsonConfigToken(JSON.stringify({
+      mcpServers: {
+        playwright: {
+          command: 'npx',
+          args: ['-y', '@playwright/mcp@latest', '--extension'],
+        },
+      },
+    }), 'abc123');
+    const parsed = JSON.parse(next);
+    expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
+  });
+
+  it('writes token into opencode mcp config', () => {
+    const next = upsertJsonConfigToken(JSON.stringify({
+      $schema: 'https://opencode.ai/config.json',
+      mcp: {
+        playwright: {
+          command: ['npx', '-y', '@playwright/mcp@latest', '--extension'],
+          enabled: true,
+          type: 'local',
+        },
+      },
+    }), 'abc123');
+    const parsed = JSON.parse(next);
+    expect(parsed.mcp.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
+  });
+});
+
+describe('doctor report rendering', () => {
+  it('renders OK-style report when tokens match', () => {
+    const text = renderBrowserDoctorReport({
+      envToken: 'abc123',
+      envFingerprint: 'fp1',
+      shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'abc123', fingerprint: 'fp1' }],
+      configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
+      remoteDebuggingEnabled: true,
+      remoteDebuggingEndpoint: 'ws://127.0.0.1:9222/devtools/browser/test',
+      cdpEnabled: false,
+      cdpToken: null,
+      cdpFingerprint: null,
+      recommendedToken: 'abc123',
+      recommendedFingerprint: 'fp1',
+      warnings: [],
+      issues: [],
+    });
+
+    expect(text).toContain('[OK] Chrome remote debugging: enabled');
+    expect(text).toContain('[OK] Environment token: configured (fp1)');
+    expect(text).toContain('[OK] MCP config /tmp/mcp.json: configured (fp1)');
+  });
+
+  it('renders MISMATCH-style report when fingerprints differ', () => {
+    const text = renderBrowserDoctorReport({
+      envToken: 'abc123',
+      envFingerprint: 'fp1',
+      shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'def456', fingerprint: 'fp2' }],
+      configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
+      remoteDebuggingEnabled: false,
+      remoteDebuggingEndpoint: null,
+      cdpEnabled: false,
+      cdpToken: null,
+      cdpFingerprint: null,
+      recommendedToken: 'abc123',
+      recommendedFingerprint: 'fp1',
+      warnings: ['Chrome remote debugging appears to be disabled or Chrome is not currently exposing a DevTools endpoint.'],
+      issues: ['Detected inconsistent Playwright MCP tokens across env/config files.'],
+    });
+
+    expect(text).toContain('[WARN] Chrome remote debugging: disabled');
+    expect(text).toContain('[MISMATCH] Environment token: configured (fp1)');
+    expect(text).toContain('[MISMATCH] Shell file /tmp/.zshrc: configured (fp2)');
+    expect(text).toContain('[MISMATCH] Recommended token fingerprint: fp1');
+  });
+});