@jackwener/opencli 0.9.8 → 1.0.1

package/dist/clis/apple-podcasts/top.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+// Apple Marketing Tools RSS API — public, no key required
+const CHARTS_URL = 'https://rss.applemarketingtools.com/api/v2';
+cli({
+    site: 'apple-podcasts',
+    name: 'top',
+    description: 'Top podcasts chart on Apple Podcasts',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of podcasts (max 100)' },
+        { name: 'country', default: 'us', help: 'Country code (e.g. us, cn, gb, jp)' },
+    ],
+    columns: ['rank', 'title', 'author', 'id'],
+    func: async (_page, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 100));
+        const country = String(args.country || 'us').trim().toLowerCase();
+        const url = `${CHARTS_URL}/${country}/podcasts/top/${limit}/podcasts.json`;
+        const resp = await fetch(url);
+        if (!resp.ok)
+            throw new CliError('FETCH_ERROR', `Charts API HTTP ${resp.status}`, `Check country code: ${country}`);
+        const data = await resp.json();
+        const results = data?.feed?.results;
+        if (!results?.length)
+            throw new CliError('NOT_FOUND', 'No chart data found', `Try a different country code`);
+        return results.map((p, i) => ({
+            rank: i + 1,
+            title: p.name,
+            author: p.artistName,
+            id: p.id,
+        }));
+    },
+});

package/dist/clis/apple-podcasts/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared Apple Podcasts utilities.
+ *
+ * Uses the public iTunes Search API — no API key required.
+ * https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/iTuneSearchAPI/
+ */
+export declare function itunesFetch(path: string): Promise<any>;
+/** Format milliseconds to mm:ss. Returns '-' for missing input. */
+export declare function formatDuration(ms: number): string;
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export declare function formatDate(iso: string): string;

package/dist/clis/apple-podcasts/utils.js

@@ -0,0 +1,30 @@
+/**
+ * Shared Apple Podcasts utilities.
+ *
+ * Uses the public iTunes Search API — no API key required.
+ * https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/iTuneSearchAPI/
+ */
+import { CliError } from '../../errors.js';
+const BASE = 'https://itunes.apple.com';
+export async function itunesFetch(path) {
+    const resp = await fetch(`${BASE}${path}`);
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `iTunes API HTTP ${resp.status}`, 'Check your search term or podcast ID');
+    }
+    return resp.json();
+}
+/** Format milliseconds to mm:ss. Returns '-' for missing input. */
+export function formatDuration(ms) {
+    if (!ms || !Number.isFinite(ms))
+        return '-';
+    const totalSec = Math.round(ms / 1000);
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    return `${m}:${String(s).padStart(2, '0')}`;
+}
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export function formatDate(iso) {
+    if (!iso)
+        return '-';
+    return iso.slice(0, 10);
+}

package/dist/clis/apple-podcasts/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/apple-podcasts/utils.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDuration, formatDate, itunesFetch } from './utils.js';
+describe('formatDuration', () => {
+    it('formats typical duration in ms', () => {
+        expect(formatDuration(3661000)).toBe('61:01');
+    });
+    it('pads single-digit seconds', () => {
+        expect(formatDuration(65000)).toBe('1:05');
+    });
+    it('formats exact minutes', () => {
+        expect(formatDuration(3600000)).toBe('60:00');
+    });
+    it('rounds fractional milliseconds', () => {
+        expect(formatDuration(3600500)).toBe('60:01');
+    });
+    it('returns dash for zero', () => {
+        expect(formatDuration(0)).toBe('-');
+    });
+    it('returns dash for NaN', () => {
+        expect(formatDuration(NaN)).toBe('-');
+    });
+});
+describe('formatDate', () => {
+    it('extracts YYYY-MM-DD from ISO string', () => {
+        expect(formatDate('2026-03-19T12:00:00.000Z')).toBe('2026-03-19');
+    });
+    it('handles date-only string', () => {
+        expect(formatDate('2025-01-01')).toBe('2025-01-01');
+    });
+    it('returns dash for empty string', () => {
+        expect(formatDate('')).toBe('-');
+    });
+    it('returns dash for undefined', () => {
+        expect(formatDate(undefined)).toBe('-');
+    });
+});
+describe('itunesFetch', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('returns parsed JSON on success', async () => {
+        const mockData = { resultCount: 1, results: [{ collectionId: 123 }] };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockData),
+        }));
+        const result = await itunesFetch('/search?term=test&media=podcast&limit=1');
+        expect(result).toEqual(mockData);
+    });
+    it('throws CliError on HTTP error', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+        }));
+        await expect(itunesFetch('/search?term=test')).rejects.toThrow('iTunes API HTTP 403');
+    });
+});

package/dist/clis/chatwise/history.js

@@ -38,6 +38,23 @@ export const historyCommand = cli({
         if (items.length === 0) {
             return [{ Index: 0, Title: 'No history found. Ensure the sidebar is visible.' }];
         }
-        return items;
+        const dateHeaders = /^(today|yesterday|last week|last month|last year|this week|this month|older|previous \d+ days|\d+ days ago)$/i;
+        const numericOnly = /^[\d\s]+$/;
+        const modelPath = /^[\w.-]+\/[\w.-]/;
+        const seen = new Set();
+        const deduped = items.filter((item) => {
+            const t = item.Title.trim();
+            if (dateHeaders.test(t))
+                return false;
+            if (numericOnly.test(t))
+                return false;
+            if (modelPath.test(t))
+                return false;
+            if (seen.has(t))
+                return false;
+            seen.add(t);
+            return true;
+        }).map((item, i) => ({ Index: i + 1, Title: item.Title }));
+        return deduped;
     },
 });

package/dist/clis/discord-app/channels.js

@@ -12,28 +12,40 @@ export const channelsCommand = cli({
         const channels = await page.evaluate(`
       (function() {
         const results = [];
-        // Discord channel list items
-        const items = document.querySelectorAll('[data-list-item-id*="channels___"], [class*="containerDefault_"]');
-        
-        items.forEach((item, i) => {
-          const nameEl = item.querySelector('[class*="name_"], [class*="channelName"]');
-          const name = nameEl ? nameEl.textContent.trim() : (item.textContent || '').trim().substring(0, 50);
-          
-          if (!name || name.length < 1) return;
-          
-          // Detect channel type from icon or aria-label
-          const iconEl = item.querySelector('[class*="icon"]');
-          let type = 'Text';
-          if (iconEl) {
-            const cls = iconEl.className || '';
-            if (cls.includes('voice') || cls.includes('speaker')) type = 'Voice';
-            else if (cls.includes('forum')) type = 'Forum';
-            else if (cls.includes('announcement')) type = 'Announcement';
-          }
-          
-          results.push({ Index: i + 1, Channel: name, Type: type });
+
+        // Discord channel links: <a> tags with href like /channels/GUILD/CHANNEL
+        const links = document.querySelectorAll('a[href*="/channels/"][data-list-item-id^="channels___"]');
+
+        links.forEach(function(el) {
+          var label = el.getAttribute('aria-label') || '';
+          if (!label) return;
+
+          // Skip categories
+          if (/[（(]category[）)]/i.test(label)) return;
+
+          // Strip any leading status prefix before the first comma (e.g. "unread, ", locale-agnostic)
+          var commaIdx = label.search(/[,，]/);
+          var cleaned = commaIdx !== -1 ? label.slice(commaIdx + 1).trimStart() : label;
+
+          // Extract name and type from "name (type)" or "name（type）"
+          var m = cleaned.match(/^(.+?)\s*[（(](.+?)[）)]\s*$/);
+          // If no type annotation found, skip — real channels always have "(Type channel)" in aria-label
+          if (!m) return;
+          var name = m[1].trim();
+          var rawType = m[2].toLowerCase();
+
+          // Discord channel names are ASCII-only; skip placeholder entries (e.g. locked channels)
+          if (!name || !/^[\x20-\x7E]+$/.test(name)) return;
+
+          var type = 'Text';
+          if (rawType.includes('voice')) type = 'Voice';
+          else if (rawType.includes('forum')) type = 'Forum';
+          else if (rawType.includes('announcement')) type = 'Announcement';
+          else if (rawType.includes('stage')) type = 'Stage';
+
+          results.push({ Index: results.length + 1, Channel: name, Type: type });
         });
-        
+
         return results;
       })()
     `);

package/dist/clis/neteasemusic/like.d.ts

@@ -0,0 +1 @@
+export declare const likeCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/like.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+export const likeCommand = cli({
+    site: 'neteasemusic',
+    name: 'like',
+    description: 'Like/unlike the currently playing song',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const result = await page.evaluate(`
+      (function() {
+        // The like/heart button in the player bar
+        const btn = document.querySelector('.m-playbar .icn-love, .m-playbar [class*="like"], .m-player [class*="love"], [data-action="like"]');
+        if (!btn) return 'Like button not found';
+        
+        const wasLiked = btn.classList.contains('loved') || btn.classList.contains('active') || btn.getAttribute('data-liked') === 'true';
+        btn.click();
+        return wasLiked ? 'Unliked' : 'Liked';
+      })()
+    `);
+        return [{ Status: result }];
+    },
+});

package/dist/clis/neteasemusic/lyrics.d.ts

@@ -0,0 +1 @@
+export declare const lyricsCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/lyrics.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+export const lyricsCommand = cli({
+    site: 'neteasemusic',
+    name: 'lyrics',
+    description: 'Get the lyrics of the currently playing song',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Line'],
+    func: async (page) => {
+        // Try to open lyrics panel if not visible
+        await page.evaluate(`
+      (function() {
+        const btn = document.querySelector('.m-playbar .icn-lyric, [class*="lyric-btn"], [data-action="lyric"]');
+        if (btn) btn.click();
+      })()
+    `);
+        await page.wait(1);
+        const lyrics = await page.evaluate(`
+      (function() {
+        // Look for lyrics container
+        const selectors = [
+          '.m-lyric p, .m-lyric [class*="line"]',
+          '[class*="lyric-content"] p',
+          '.listlyric li',
+          '[class*="lyric"] [class*="line"]',
+          '.j-lyric p',
+        ];
+        
+        for (const sel of selectors) {
+          const nodes = document.querySelectorAll(sel);
+          if (nodes.length > 0) {
+            return Array.from(nodes).map(n => (n.textContent || '').trim()).filter(l => l.length > 0);
+          }
+        }
+        
+        // Fallback: try the body text for any lyrics-like content
+        return [];
+      })()
+    `);
+        if (lyrics.length === 0) {
+            return [{ Line: 'No lyrics found. Try opening the lyrics panel first.' }];
+        }
+        return lyrics.map((line) => ({ Line: line }));
+    },
+});

package/dist/clis/neteasemusic/next.d.ts

@@ -0,0 +1 @@
+export declare const nextCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/next.js

@@ -0,0 +1,26 @@
+import { cli, Strategy } from '../../registry.js';
+export const nextCommand = cli({
+    site: 'neteasemusic',
+    name: 'next',
+    description: 'Skip to the next song',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const clicked = await page.evaluate(`
+      (function() {
+        const btn = document.querySelector('.m-playbar .btnfwd, .m-playbar [class*="next"], .m-player .btn-next, [data-action="next"]');
+        if (btn) { btn.click(); return true; }
+        return false;
+      })()
+    `);
+        if (!clicked) {
+            // Fallback: Ctrl+Right is common next-track shortcut
+            await page.pressKey('Control+ArrowRight');
+        }
+        await page.wait(1);
+        return [{ Status: 'Skipped to next song' }];
+    },
+});

package/dist/clis/neteasemusic/play.d.ts

@@ -0,0 +1 @@
+export declare const playCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/play.js

@@ -0,0 +1,26 @@
+import { cli, Strategy } from '../../registry.js';
+export const playCommand = cli({
+    site: 'neteasemusic',
+    name: 'play',
+    description: 'Toggle play/pause for the current song',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        // Click the play/pause button or use Space key
+        const clicked = await page.evaluate(`
+      (function() {
+        const btn = document.querySelector('.m-playbar .btnp, .m-playbar [class*="play"], .m-player .btn-play, [data-action="play"]');
+        if (btn) { btn.click(); return true; }
+        return false;
+      })()
+    `);
+        if (!clicked) {
+            // Fallback: use Space key which is the universal play/pause shortcut
+            await page.pressKey('Space');
+        }
+        return [{ Status: 'Play/Pause toggled' }];
+    },
+});

package/dist/clis/neteasemusic/playing.d.ts

@@ -0,0 +1 @@
+export declare const playingCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/playing.js

@@ -0,0 +1,59 @@
+import { cli, Strategy } from '../../registry.js';
+export const playingCommand = cli({
+    site: 'neteasemusic',
+    name: 'playing',
+    description: 'Get the currently playing song info',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Title', 'Artist', 'Album', 'Duration', 'Progress'],
+    func: async (page) => {
+        const info = await page.evaluate(`
+      (function() {
+        // NeteaseMusic player bar is at the bottom
+        const selectors = {
+          title: '.m-playbar .j-song .name, .m-playbar .song .name, [class*="playing"] .name, .m-player .name',
+          artist: '.m-playbar .j-song .by, .m-playbar .song .by, [class*="playing"] .artist, .m-player .by',
+          album: '.m-playbar .j-song .album, [class*="playing"] .album',
+          time: '.m-playbar .j-dur, .m-playbar .time, .m-player .time',
+          progress: '.m-playbar .barbg .rng, .m-playbar [role="progressbar"], .m-player [class*="progress"]',
+        };
+        
+        function getText(sel) {
+          for (const s of sel.split(',')) {
+            const el = document.querySelector(s.trim());
+            if (el) return (el.textContent || el.innerText || '').trim();
+          }
+          return '';
+        }
+        
+        const title = getText(selectors.title);
+        const artist = getText(selectors.artist);
+        const album = getText(selectors.album);
+        const time = getText(selectors.time);
+        
+        // Try to get playback progress from the progress bar width
+        let progress = '';
+        const bar = document.querySelector('.m-playbar .barbg .rng, [class*="progress"] [class*="played"]');
+        if (bar) {
+          const style = bar.getAttribute('style') || '';
+          const match = style.match(/width:\\s*(\\d+\\.?\\d*)%/);
+          if (match) progress = match[1] + '%';
+        }
+        
+        if (!title) {
+          // Fallback: try document title which often contains "songName - NeteaseMusic"
+          const docTitle = document.title;
+          if (docTitle && !docTitle.includes('NeteaseMusic')) {
+            return { Title: docTitle, Artist: '', Album: '', Duration: '', Progress: '' };
+          }
+          return { Title: 'No song playing', Artist: '—', Album: '—', Duration: '—', Progress: '—' };
+        }
+        
+        return { Title: title, Artist: artist, Album: album, Duration: time, Progress: progress };
+      })()
+    `);
+        return [info];
+    },
+});

package/dist/clis/neteasemusic/playlist.d.ts

@@ -0,0 +1 @@
+export declare const playlistCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/playlist.js

@@ -0,0 +1,46 @@
+import { cli, Strategy } from '../../registry.js';
+export const playlistCommand = cli({
+    site: 'neteasemusic',
+    name: 'playlist',
+    description: 'Show the current playback queue / playlist',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Title', 'Artist'],
+    func: async (page) => {
+        // Open the playlist panel (usually a button at the bottom bar)
+        await page.evaluate(`
+      (function() {
+        const btn = document.querySelector('.m-playbar .icn-list, .m-playbar [class*="playlist"], [data-action="playlist"], .m-playbar .btnlist');
+        if (btn) btn.click();
+      })()
+    `);
+        await page.wait(1);
+        const items = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Playlist panel items
+        const rows = document.querySelectorAll('.m-playlist li, [class*="playlist-panel"] li, .listlyric li, .j-playlist li');
+        
+        rows.forEach((row, i) => {
+          const nameEl = row.querySelector('.name, [class*="name"], a, span:first-child');
+          const artistEl = row.querySelector('.by, [class*="artist"], .ar');
+          
+          const title = nameEl ? (nameEl.getAttribute('title') || nameEl.textContent || '').trim() : (row.textContent || '').trim();
+          const artist = artistEl ? (artistEl.textContent || '').trim() : '';
+          
+          if (title && title.length > 0) {
+            results.push({ Index: i + 1, Title: title.substring(0, 80), Artist: artist });
+          }
+        });
+        
+        return results;
+      })()
+    `);
+        if (items.length === 0) {
+            return [{ Index: 0, Title: 'Playlist is empty or panel not open', Artist: '—' }];
+        }
+        return items;
+    },
+});

package/dist/clis/neteasemusic/prev.d.ts

@@ -0,0 +1 @@
+export declare const prevCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/prev.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+export const prevCommand = cli({
+    site: 'neteasemusic',
+    name: 'prev',
+    description: 'Go back to the previous song',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const clicked = await page.evaluate(`
+      (function() {
+        const btn = document.querySelector('.m-playbar .btnbak, .m-playbar [class*="prev"], .m-player .btn-prev, [data-action="prev"]');
+        if (btn) { btn.click(); return true; }
+        return false;
+      })()
+    `);
+        if (!clicked) {
+            await page.pressKey('Control+ArrowLeft');
+        }
+        await page.wait(1);
+        return [{ Status: 'Went to previous song' }];
+    },
+});

package/dist/clis/neteasemusic/search.d.ts

@@ -0,0 +1 @@
+export declare const searchCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/search.js

@@ -0,0 +1,52 @@
+import { cli, Strategy } from '../../registry.js';
+export const searchCommand = cli({
+    site: 'neteasemusic',
+    name: 'search',
+    description: 'Search for songs, artists, albums, or playlists',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'query', required: true, positional: true, help: 'Search query' }],
+    columns: ['Index', 'Title', 'Artist'],
+    func: async (page, kwargs) => {
+        const query = kwargs.query;
+        // Focus and fill the search box
+        await page.evaluate(`
+      (function(q) {
+        const input = document.querySelector('.m-search input, #srch, [class*="search"] input, input[type="search"]');
+        if (!input) throw new Error('Search input not found');
+        input.focus();
+        const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set;
+        setter.call(input, q);
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+      })(${JSON.stringify(query)})
+    `);
+        await page.pressKey('Enter');
+        await page.wait(2);
+        // Scrape results
+        const results = await page.evaluate(`
+      (function() {
+        const items = [];
+        // Song list items in search results
+        const rows = document.querySelectorAll('.srchsongst li, .m-table tbody tr, [class*="songlist"] [class*="item"], table tbody tr');
+        
+        rows.forEach((row, i) => {
+          if (i >= 20) return;
+          const nameEl = row.querySelector('.sn, .name a, [class*="songName"], td:nth-child(2) a, b[title]');
+          const artistEl = row.querySelector('.ar, .artist, [class*="artist"], td:nth-child(4) a, td:nth-child(3) a');
+          
+          const title = nameEl ? (nameEl.getAttribute('title') || nameEl.textContent || '').trim() : '';
+          const artist = artistEl ? (artistEl.getAttribute('title') || artistEl.textContent || '').trim() : '';
+          
+          if (title) items.push({ Index: i + 1, Title: title, Artist: artist });
+        });
+        
+        return items;
+      })()
+    `);
+        if (results.length === 0) {
+            return [{ Index: 0, Title: `No results for "${query}"`, Artist: '—' }];
+        }
+        return results;
+    },
+});

package/dist/clis/neteasemusic/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/status.js

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'neteasemusic',
+    name: 'status',
+    description: 'Check CDP connection to NeteaseMusic Desktop',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status', 'Url', 'Title'],
+    func: async (page) => {
+        const url = await page.evaluate('window.location.href');
+        const title = await page.evaluate('document.title');
+        return [{ Status: 'Connected', Url: url, Title: title }];
+    },
+});

package/dist/clis/neteasemusic/volume.d.ts

@@ -0,0 +1 @@
+export declare const volumeCommand: import("../../registry.js").CliCommand;

package/dist/clis/neteasemusic/volume.js

@@ -0,0 +1,54 @@
+import { cli, Strategy } from '../../registry.js';
+export const volumeCommand = cli({
+    site: 'neteasemusic',
+    name: 'volume',
+    description: 'Get or set the volume level (0-100)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'level', required: false, positional: true, help: 'Volume level 0-100 (omit to read current)' },
+    ],
+    columns: ['Status', 'Volume'],
+    func: async (page, kwargs) => {
+        const level = kwargs.level;
+        if (!level) {
+            // Read current volume
+            const vol = await page.evaluate(`
+        (function() {
+          const bar = document.querySelector('.m-playbar .vol .barbg .rng, [class*="volume"] [class*="progress"], [class*="volume"] [class*="played"]');
+          if (bar) {
+            const style = bar.getAttribute('style') || '';
+            const match = style.match(/width:\\s*(\\d+\\.?\\d*)%/);
+            if (match) return match[1];
+          }
+          
+          const vol = document.querySelector('.m-playbar .j-vol, [class*="volume-value"]');
+          if (vol) return vol.textContent.trim();
+          
+          return 'Unknown';
+        })()
+      `);
+            return [{ Status: 'Current', Volume: vol + '%' }];
+        }
+        // Set volume by clicking on the volume bar at the right position
+        const targetVol = Math.max(0, Math.min(100, parseInt(level, 10)));
+        await page.evaluate(`
+      (function(target) {
+        const bar = document.querySelector('.m-playbar .vol .barbg, [class*="volume-bar"], [class*="volume"] [class*="track"]');
+        if (!bar) return;
+        
+        const rect = bar.getBoundingClientRect();
+        const x = rect.left + (rect.width * target / 100);
+        const y = rect.top + rect.height / 2;
+        
+        bar.dispatchEvent(new MouseEvent('click', {
+          clientX: x,
+          clientY: y,
+          bubbles: true,
+        }));
+      })(${targetVol})
+    `);
+        return [{ Status: 'Set', Volume: targetVol + '%' }];
+    },
+});

package/dist/clis/twitter/accept.d.ts

@@ -0,0 +1 @@
+export {};