publishport-opencli 1.8.4-pp.1

package/clis/trae-solo/workspaces-fs.js

@@ -0,0 +1,113 @@
+// Workspace + extension enumeration commands for Trae SOLO.
+//
+//   workspaces-list  — list workspaceStorage uuids + resolved folder paths
+//   extensions-list  — list installed VSCode extensions from extensions.json
+//
+// READ-ONLY. Works while Trae SOLO is closed.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    CommandExecutionError,
+    EmptyResultError,
+} from '@jackwener/opencli/errors';
+import {
+    TRAE_WORKSPACE_STORAGE,
+    TRAE_EXTENSIONS_JSON,
+    resolveWorkspaceJson,
+} from './_state.js';
+
+// -------- workspaces-list --------
+cli({
+    site: 'trae-solo',
+    name: 'workspaces-list',
+    access: 'read',
+    description: 'List Trae SOLO workspaceStorage entries (~/Library/.../TRAE SOLO/User/workspaceStorage/<uuid>/), resolving each workspace.json to its single-folder path or multi-folder workspace target. Works while Trae is closed.',
+    domain: 'localhost',
+    browser: false,
+    strategy: Strategy.LOCAL,
+    args: [
+        { name: 'limit', type: 'int', required: false, default: 100 },
+    ],
+    columns: ['Index', 'Workspace Id', 'Kind', 'Target', 'Modified', 'Id', 'Version', 'Source', 'Installed'],
+    func: async (args) => {
+        if (!fs.existsSync(TRAE_WORKSPACE_STORAGE)) {
+            throw new CommandExecutionError(
+                `workspaceStorage not found: ${TRAE_WORKSPACE_STORAGE}`,
+                '',
+            );
+        }
+        const dirs = fs.readdirSync(TRAE_WORKSPACE_STORAGE).filter((n) => {
+            const full = path.join(TRAE_WORKSPACE_STORAGE, n);
+            return fs.statSync(full).isDirectory();
+        });
+        if (!dirs.length) {
+            throw new EmptyResultError('trae-solo workspaces-list', 'No workspace storage entries.');
+        }
+        const rows = dirs.map((id) => {
+            const dir = path.join(TRAE_WORKSPACE_STORAGE, id);
+            const wj = path.join(dir, 'workspace.json');
+            const resolved = resolveWorkspaceJson(wj);
+            const mtime = fs.statSync(dir).mtimeMs;
+            return { id, kind: resolved.kind, target: resolved.target, mtime };
+        }).sort((a, b) => b.mtime - a.mtime);
+        const limit = Number.isInteger(args.limit) && args.limit > 0 ? args.limit : 100;
+        return rows.slice(0, limit).map((r, i) => ({
+            Index: i + 1,
+            'Workspace Id': r.id,
+            Kind: r.kind,
+            Target: (r.target || '').slice(0, 120),
+            Modified: new Date(r.mtime).toISOString().replace('T', ' ').slice(0, 19),
+            Id: '',
+            Version: '',
+            Source: '',
+            Installed: '',
+        }));
+    },
+});
+
+// -------- extensions-list --------
+cli({
+    site: 'trae-solo',
+    name: 'extensions-list',
+    access: 'read',
+    description: 'List VSCode extensions installed in Trae SOLO (~/.trae/extensions/extensions.json). Works while Trae is closed.',
+    domain: 'localhost',
+    browser: false,
+    strategy: Strategy.LOCAL,
+    args: [],
+    columns: ['Index', 'Workspace Id', 'Kind', 'Target', 'Modified', 'Id', 'Version', 'Source', 'Installed'],
+    func: async () => {
+        if (!fs.existsSync(TRAE_EXTENSIONS_JSON)) {
+            throw new CommandExecutionError(
+                `extensions.json not found: ${TRAE_EXTENSIONS_JSON}`,
+                'Trae SOLO has not installed any VSCode extensions yet.',
+            );
+        }
+        let arr;
+        try {
+            arr = JSON.parse(fs.readFileSync(TRAE_EXTENSIONS_JSON, 'utf-8'));
+        } catch (e) {
+            throw new CommandExecutionError(`Failed to parse extensions.json: ${e.message}`, '');
+        }
+        if (!Array.isArray(arr) || !arr.length) {
+            throw new EmptyResultError('trae-solo extensions-list', 'No extensions installed.');
+        }
+        return arr.map((e, i) => {
+            const ts = e?.metadata?.installedTimestamp;
+            const installed = ts ? new Date(ts).toISOString().replace('T', ' ').slice(0, 19) : '';
+            return {
+                Index: i + 1,
+                'Workspace Id': '',
+                Kind: '',
+                Target: '',
+                Modified: '',
+                Id: e?.identifier?.id || '?',
+                Version: e?.version || '',
+                Source: e?.metadata?.source || '',
+                Installed: installed,
+            };
+        });
+    },
+});

package/clis/tvmaze/search.js

@@ -0,0 +1,61 @@
+// tvmaze search — TV show search by title.
+//
+// Hits `https://api.tvmaze.com/search/shows?q=<query>` and returns one row per
+// match. Includes the show id (round-tripable into `tvmaze show <id>`),
+// premiered/ended dates, network, and TVmaze rating so agents can rank.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    TVMAZE_BASE, joinList, requireBoundedInt, requireString, stripHtml, tvmazeFetch,
+} from './utils.js';
+
+cli({
+    site: 'tvmaze',
+    name: 'search',
+    access: 'read',
+    description: 'TVmaze TV show search by title (returns id, name, network, premiered/ended, rating)',
+    domain: 'tvmaze.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, type: 'string', required: true, help: 'TV show title or fragment to search for' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max rows to return (1-50)' },
+    ],
+    columns: [
+        'rank', 'id', 'name', 'type', 'language', 'genres',
+        'status', 'premiered', 'ended', 'network', 'rating',
+        'matchScore', 'summary', 'url',
+    ],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 20, 50, 'limit');
+        const list = await tvmazeFetch(
+            `${TVMAZE_BASE}/search/shows?q=${encodeURIComponent(query)}`,
+            `tvmaze search ${query}`,
+        );
+        if (!Array.isArray(list) || list.length === 0) {
+            throw new EmptyResultError('tvmaze search', `TVmaze returned no shows matching "${query}".`);
+        }
+        const rows = list.slice(0, limit).map((entry, i) => {
+            const show = entry?.show ?? {};
+            const network = show.network?.name ?? show.webChannel?.name ?? '';
+            return {
+                rank: i + 1,
+                id: typeof show.id === 'number' ? show.id : null,
+                name: String(show.name ?? '').trim(),
+                type: String(show.type ?? '').trim(),
+                language: String(show.language ?? '').trim(),
+                genres: joinList(show.genres),
+                status: String(show.status ?? '').trim(),
+                premiered: typeof show.premiered === 'string' ? show.premiered : null,
+                ended: typeof show.ended === 'string' ? show.ended : null,
+                network: String(network).trim(),
+                rating: show.rating?.average == null ? null : Number(show.rating.average),
+                matchScore: typeof entry?.score === 'number' ? entry.score : null,
+                summary: stripHtml(show.summary),
+                url: String(show.url ?? '').trim(),
+            };
+        });
+        return rows;
+    },
+});

package/clis/tvmaze/show.js

@@ -0,0 +1,60 @@
+// tvmaze show — full TV show details by TVmaze id.
+//
+// Hits `https://api.tvmaze.com/shows/<id>`. Returns one row with name, status,
+// premiered/ended dates, network, runtime, rating, official site, IMDB / TheTVDB
+// cross-refs (so agents can hop into other adapters), and a plain-text summary.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { TVMAZE_BASE, joinList, requireShowId, stripHtml, tvmazeFetch } from './utils.js';
+
+cli({
+    site: 'tvmaze',
+    name: 'show',
+    access: 'read',
+    description: 'Single TVmaze TV show detail by id (network, schedule, rating, IMDB/TheTVDB cross-refs)',
+    domain: 'tvmaze.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, type: 'int', required: true, help: 'TVmaze show id (positive integer)' },
+    ],
+    columns: [
+        'id', 'name', 'type', 'language', 'genres', 'status',
+        'premiered', 'ended', 'runtime', 'averageRuntime', 'network',
+        'country', 'schedule', 'rating', 'imdb', 'thetvdb',
+        'officialSite', 'summary', 'url',
+    ],
+    func: async (args) => {
+        const id = requireShowId(args.id);
+        const show = await tvmazeFetch(`${TVMAZE_BASE}/shows/${id}`, `tvmaze show ${id}`);
+        if (!show || show.id == null) {
+            throw new EmptyResultError('tvmaze show', `TVmaze returned no show for id ${id}.`);
+        }
+        const network = show.network?.name ?? show.webChannel?.name ?? '';
+        const country = show.network?.country?.name ?? show.webChannel?.country?.name ?? '';
+        const days = Array.isArray(show.schedule?.days) ? show.schedule.days.join(', ') : '';
+        const time = String(show.schedule?.time ?? '').trim();
+        const schedule = days || time ? `${days}${days && time ? ' ' : ''}${time}`.trim() : '';
+        return [{
+            id: Number(show.id),
+            name: String(show.name ?? '').trim(),
+            type: String(show.type ?? '').trim(),
+            language: String(show.language ?? '').trim(),
+            genres: joinList(show.genres),
+            status: String(show.status ?? '').trim(),
+            premiered: typeof show.premiered === 'string' ? show.premiered : null,
+            ended: typeof show.ended === 'string' ? show.ended : null,
+            runtime: show.runtime == null ? null : Number(show.runtime),
+            averageRuntime: show.averageRuntime == null ? null : Number(show.averageRuntime),
+            network: String(network).trim(),
+            country: String(country).trim(),
+            schedule,
+            rating: show.rating?.average == null ? null : Number(show.rating.average),
+            imdb: String(show.externals?.imdb ?? '').trim(),
+            thetvdb: show.externals?.thetvdb == null ? null : Number(show.externals.thetvdb),
+            officialSite: String(show.officialSite ?? '').trim(),
+            summary: stripHtml(show.summary),
+            url: String(show.url ?? '').trim(),
+        }];
+    },
+});

package/clis/tvmaze/tvmaze.test.js

@@ -0,0 +1,93 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './show.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('tvmaze search adapter', () => {
+    const cmd = getRegistry().get('tvmaze/search');
+
+    it('rejects empty query and bad limit before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ query: '', limit: 5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 100 })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        await expect(cmd.func({ query: 'foo', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when no shows match', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('[]', { status: 200 })));
+        await expect(cmd.func({ query: 'asdfghjkl', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('strips HTML from summary and ids round-trip into tvmaze show <id>', async () => {
+        const list = [{
+            score: 1.2,
+            show: {
+                id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English',
+                genres: ['Drama'], status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11',
+                network: { name: 'AMC' }, rating: { average: 9.2 },
+                summary: '<p><b>Breaking Bad</b> is a show with &amp; entities &#39;here&#39;, &#x27;hex&#x27;, and &hellip;.</p>',
+                url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+            },
+        }];
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(list), { status: 200 })));
+
+        const rows = await cmd.func({ query: 'breaking bad', limit: 5 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, id: 169, name: 'Breaking Bad', network: 'AMC', rating: 9.2, matchScore: 1.2,
+        });
+        expect(rows[0].summary).toBe("Breaking Bad is a show with & entities 'here', 'hex', and ….");
+        // id round-trip
+        expect(typeof rows[0].id).toBe('number');
+    });
+});
+
+describe('tvmaze show adapter', () => {
+    const cmd = getRegistry().get('tvmaze/show');
+
+    it('rejects non-positive id before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: -5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'abc' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 404 to EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
+        await expect(cmd.func({ id: 99999999 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('returns full show detail with externals + schedule', async () => {
+        const show = {
+            id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English', genres: ['Drama'],
+            status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11', runtime: 60, averageRuntime: 60,
+            network: { name: 'AMC', country: { name: 'United States' } }, schedule: { time: '22:00', days: ['Sunday'] },
+            rating: { average: 9.2 }, externals: { imdb: 'tt0903747', thetvdb: 81189 },
+            officialSite: 'http://www.amc.com/shows/breaking-bad',
+            summary: '<p>Plain.</p>', url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(show), { status: 200 })));
+
+        const rows = await cmd.func({ id: 169 });
+        expect(rows[0]).toMatchObject({
+            id: 169, name: 'Breaking Bad', country: 'United States', schedule: 'Sunday 22:00',
+            imdb: 'tt0903747', thetvdb: 81189, rating: 9.2, summary: 'Plain.',
+        });
+    });
+});

package/clis/tvmaze/utils.js

@@ -0,0 +1,110 @@
+// Shared helpers for the TVmaze adapters.
+//
+// TVmaze publishes a free, unauthenticated REST API at https://api.tvmaze.com.
+// Docs: https://www.tvmaze.com/api
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const TVMAZE_BASE = 'https://api.tvmaze.com';
+const UA = 'opencli-tvmaze-adapter (+https://github.com/jackwener/opencli)';
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`tvmaze ${label} cannot be empty`);
+    return s;
+}
+
+export function requireShowId(value) {
+    const raw = value;
+    const n = typeof raw === 'number' ? raw : Number(String(raw ?? '').trim());
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(
+            'tvmaze show id is required and must be a positive integer',
+            'TVmaze show ids appear in the URL: https://www.tvmaze.com/shows/<id>/<slug>.',
+        );
+    }
+    return n;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`tvmaze ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`tvmaze ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function tvmazeFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.tvmaze.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `TVmaze returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'TVmaze caps unauthenticated traffic at ~20 req/10s; wait a few seconds and retry.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+const HTML_ENTITY_MAP = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+    rsquo: '’',
+    lsquo: '‘',
+    rdquo: '”',
+    ldquo: '“',
+    hellip: '…',
+    ndash: '–',
+    mdash: '—',
+};
+
+// TVmaze ships HTML in `summary` ("<p><b>...</b> ...</p>"). Strip tags + decode
+// named and numeric entities so output is plain text.
+export function stripHtml(html) {
+    if (html == null) return '';
+    let s = String(html);
+    s = s.replace(/<[^>]+>/g, '');
+    s = s
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => {
+            const code = parseInt(hex, 16);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&#(\d+);/g, (_, dec) => {
+            const code = parseInt(dec, 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&([a-zA-Z]+);/g, (match, name) => HTML_ENTITY_MAP[name] ?? match);
+    return s.replace(/\s+/g, ' ').trim();
+}
+
+export function joinList(value) {
+    return Array.isArray(value) ? value.filter(Boolean).join(', ') : '';
+}

package/clis/twitter/accept.js

@@ -0,0 +1,204 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'twitter',
+    name: 'accept',
+    access: 'write',
+    description: 'Auto-accept DM requests containing specific keywords',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'query', type: 'string', required: true, positional: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
+        { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+        { name: 'timeout', type: 'int', required: false, default: 600, help: 'Max seconds for the overall command (default: 600 — batch op)' },
+    ],
+    columns: ['index', 'status', 'user', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter accept');
+        const keywords = kwargs.query.split(',').map((k) => k.trim()).filter(Boolean);
+        const maxAccepts = kwargs.max ?? 20;
+        const results = [];
+        let acceptCount = 0;
+        // Track already-visited conversations to avoid infinite loops
+        const visited = new Set();
+        for (let round = 0; round < maxAccepts + 50; round++) {
+            if (acceptCount >= maxAccepts)
+                break;
+            // Step 1: Navigate to DM requests page
+            await page.goto('https://x.com/messages/requests');
+            await page.wait(4);
+            // Step 2: Get conversations with scroll-to-load
+            const convInfo = await page.evaluate(`(async () => {
+        try {
+          // Wait for initial items
+          let attempts = 0;
+          while (attempts < 10) {
+            const convs = document.querySelectorAll('[data-testid="conversation"]');
+            if (convs.length > 0) break;
+            await new Promise(r => setTimeout(r, 1000));
+            attempts++;
+          }
+
+          // Scroll to load more
+          const seenCount = new Set();
+          let noNewCount = 0;
+          for (let scroll = 0; scroll < 20; scroll++) {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const prevSize = seenCount.size;
+            convs.forEach((_, i) => seenCount.add(i));
+            if (convs.length >= ${maxAccepts + 10}) break;
+
+            // Scroll last item into view
+            if (convs.length > 0) {
+              convs[convs.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+            }
+            await new Promise(r => setTimeout(r, 1500));
+
+            if (seenCount.size <= prevSize) {
+              noNewCount++;
+              if (noNewCount >= 3) break;
+            } else {
+              noNewCount = 0;
+            }
+          }
+
+          const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+          if (convs.length === 0) return { ok: false, count: 0, items: [] };
+
+          const items = convs.map((conv, idx) => {
+            const text = conv.innerText || '';
+            const link = conv.querySelector('a[href]');
+            const href = link ? link.href : '';
+            const lines = text.split('\\n').filter(l => l.trim());
+            const user = lines[0] || 'Unknown';
+            return { idx, text, href, user };
+          });
+          return { ok: true, count: convs.length, items };
+        } catch(e) {
+          return { ok: false, error: String(e), count: 0, items: [] };
+        }
+      })()`);
+            if (!convInfo?.ok || convInfo.count === 0) {
+                if (results.length === 0) {
+                    results.push({ index: 1, status: 'info', user: 'System', message: 'No message requests found' });
+                }
+                break;
+            }
+            let foundInThisRound = false;
+            // Step 3: Find first unvisited conversation with keyword match in preview
+            for (const item of convInfo.items) {
+                if (acceptCount >= maxAccepts)
+                    break;
+                const convKey = item.href || `conv-${item.idx}`;
+                if (visited.has(convKey))
+                    continue;
+                visited.add(convKey);
+                // Check if preview text contains any keyword
+                const previewMatch = keywords.some((k) => item.text.includes(k));
+                if (!previewMatch)
+                    continue;
+                // Step 4: Click this conversation to open it
+                const clickResult = await page.evaluate(`(async () => {
+          try {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const conv = convs[${item.idx}];
+            if (!conv) return { ok: false, error: 'Conversation element not found' };
+            conv.click();
+            await new Promise(r => setTimeout(r, 2000));
+            return { ok: true };
+          } catch(e) {
+            return { ok: false, error: String(e) };
+          }
+        })()`);
+                if (!clickResult?.ok)
+                    continue;
+                // Wait for conversation to load
+                await page.wait(2);
+                // Step 5: Read full chat content and find Accept button
+                const res = await page.evaluate(`(async () => {
+          try {
+            const keywords = ${JSON.stringify(keywords)};
+
+            // Get username from conversation header
+            const heading = document.querySelector('[data-testid="conversation-header"]') ||
+                            document.querySelector('[data-testid="DM-conversation-header"]');
+            let username = 'Unknown';
+            if (heading) {
+              username = heading.innerText.trim().split('\\n')[0];
+            }
+
+            // Read full chat area text
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('[data-testid="DMConversationBody"]') ||
+                             document.querySelector('main [data-testid="cellInnerDiv"]')?.closest('section') ||
+                             document.querySelector('main');
+            const text = chatArea ? chatArea.innerText : '';
+
+            // Verify keyword match in full chat content
+            const matchedKw = keywords.filter(k => text.includes(k));
+            if (matchedKw.length === 0) {
+              return { status: 'skipped', user: username, message: 'No keyword match in full content' };
+            }
+
+            // Find the Accept button
+            const allBtns = Array.from(document.querySelectorAll('[role="button"]'));
+            const acceptBtn = allBtns.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return t === 'accept' || t === '接受';
+            });
+
+            if (!acceptBtn) {
+              return { status: 'no_button', user: username, message: 'Keyword matched but no Accept button (already accepted?)' };
+            }
+
+            // Click Accept
+            acceptBtn.click();
+            await new Promise(r => setTimeout(r, 2000));
+
+            // Check for confirmation dialog
+            const btnsAfter = Array.from(document.querySelectorAll('[role="button"]'));
+            const confirmBtn = btnsAfter.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return (t === 'accept' || t === '接受') && btn !== acceptBtn;
+            });
+            if (confirmBtn) {
+              confirmBtn.click();
+              await new Promise(r => setTimeout(r, 1000));
+            }
+
+            return { status: 'accepted', user: username, message: 'Accepted! Matched: ' + matchedKw.join(', ') };
+          } catch(e) {
+            return { status: 'error', user: 'system', message: String(e) };
+          }
+        })()`);
+                if (res?.status === 'accepted') {
+                    acceptCount++;
+                    foundInThisRound = true;
+                    results.push({
+                        index: acceptCount,
+                        status: 'accepted',
+                        user: res.user || 'Unknown',
+                        message: res.message || 'Accepted',
+                    });
+                    // After accept, Twitter redirects to /messages — loop back to /messages/requests
+                    await page.wait(2);
+                    break; // break inner loop, outer loop will re-navigate to requests
+                }
+                else if (res?.status === 'no_button') {
+                    // Already accepted, skip
+                    continue;
+                }
+            }
+            // If no match found in this round, we've exhausted all visible requests
+            if (!foundInThisRound) {
+                break;
+            }
+        }
+        if (results.length === 0) {
+            results.push({ index: 0, status: 'info', user: 'System', message: `No requests matched keywords "${keywords.join(', ')}"` });
+        }
+        return results;
+    }
+});