@jackwener/opencli 1.7.2 → 1.7.4

package/clis/chatgpt/utils.js

@@ -0,0 +1,297 @@
+/**
+ * ChatGPT web browser automation helpers for image generation.
+ * Cross-platform: works on Linux/macOS/Windows via OpenCLI's CDP browser automation.
+ */
+
+export const CHATGPT_DOMAIN = 'chatgpt.com';
+export const CHATGPT_URL = 'https://chatgpt.com';
+
+// Selectors
+const COMPOSER_SELECTOR = '[aria-label="Chat with ChatGPT"]';
+const SEND_BTN_SELECTOR = 'button[aria-label="Send prompt"]';
+
+function buildComposerLocatorScript() {
+    const selectorsJson = JSON.stringify([COMPOSER_SELECTOR]);
+    const markerAttr = 'data-opencli-chatgpt-composer';
+    return `
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+
+      const markerAttr = ${JSON.stringify(markerAttr)};
+      const clearMarkers = (active) => {
+        document.querySelectorAll('[' + markerAttr + ']').forEach(node => {
+          if (node !== active) node.removeAttribute(markerAttr);
+        });
+      };
+
+      const findComposer = () => {
+        const marked = document.querySelector('[' + markerAttr + '="1"]');
+        if (marked instanceof HTMLElement && isVisible(marked)) return marked;
+
+        for (const selector of ${JSON.stringify([COMPOSER_SELECTOR])}) {
+          const node = Array.from(document.querySelectorAll(selector)).find(c => c instanceof HTMLElement && isVisible(c));
+          if (node instanceof HTMLElement) {
+            node.setAttribute(markerAttr, '1');
+            return node;
+          }
+        }
+        return null;
+      };
+
+      findComposer.toString = () => 'findComposer';
+      return { findComposer, markerAttr };
+    `;
+}
+
+/**
+ * Send a message to the ChatGPT composer and submit it.
+ * Returns true if the message was sent successfully.
+ */
+export async function sendChatGPTMessage(page, text) {
+    // Close sidebar if open (it can cover the chat composer)
+    await page.evaluate(`
+        (() => {
+            const closeBtn = Array.from(document.querySelectorAll('button')).find(b => b.getAttribute('aria-label') === 'Close sidebar');
+            if (closeBtn) closeBtn.click();
+        })()
+    `);
+    await page.wait(0.5);
+
+    // Wait for composer to be ready and use Playwright's type()
+    await page.wait(1.5);
+    
+    const typeResult = await page.evaluate(`
+        (() => {
+            ${buildComposerLocatorScript()}
+            const composer = findComposer();
+            if (!composer) return false;
+            composer.focus();
+            composer.textContent = '';
+            return true;
+        })()
+    `);
+    
+    if (!typeResult) return false;
+    
+    // Use page.type() which is Playwright's native method
+    try {
+        if (page.nativeType) {
+            await page.nativeType(text);
+        } else {
+            throw new Error('nativeType unavailable');
+        }
+    } catch (e) {
+        // Fallback: use execCommand
+        await page.evaluate(`
+            (() => {
+                const composer = document.querySelector('[aria-label="Chat with ChatGPT"]');
+                if (!composer) return;
+                composer.focus();
+                document.execCommand('insertText', false, ${JSON.stringify(text)});
+            })()
+        `);
+    }
+    
+    // Wait for send button to appear (it only shows when there's text)
+    await page.wait(1.5);
+
+    // Click send button
+    const sent = await page.evaluate(`
+        (() => {
+            const btns = Array.from(document.querySelectorAll('button'));
+            const sendBtn = btns.find(b => b.getAttribute('aria-label') === 'Send prompt');
+            return { sendBtnFound: !!sendBtn };
+        })()
+    `);
+    
+    if (!sent || !sent.sendBtnFound) {
+        return false;
+    }
+    
+    await page.evaluate(`
+        (() => {
+            const sendBtn = Array.from(document.querySelectorAll('button')).find(b => b.getAttribute('aria-label') === 'Send prompt');
+            if (sendBtn) sendBtn.click();
+        })()
+    `);
+    return true;
+}
+
+/**
+ * Check if ChatGPT is still generating a response.
+ */
+export async function isGenerating(page) {
+    return await page.evaluate(`
+        (() => {
+            return Array.from(document.querySelectorAll('button')).some(b => {
+                const label = b.getAttribute('aria-label') || '';
+                return label === 'Stop generating' || label.includes('Thinking');
+            });
+        })()
+    `);
+}
+
+/**
+ * Get visible image URLs from the ChatGPT page (excluding profile/avatar images).
+ */
+export async function getChatGPTVisibleImageUrls(page) {
+    return await page.evaluate(`
+        (() => {
+            const isVisible = (el) => {
+                if (!(el instanceof HTMLElement)) return false;
+                const style = window.getComputedStyle(el);
+                if (style.display === 'none' || style.visibility === 'hidden') return false;
+                const rect = el.getBoundingClientRect();
+                return rect.width > 32 && rect.height > 32;
+            };
+
+            const imgs = Array.from(document.querySelectorAll('img')).filter(img =>
+                img instanceof HTMLImageElement && isVisible(img)
+            );
+
+            const urls = [];
+            const seen = new Set();
+
+            for (const img of imgs) {
+                const src = img.currentSrc || img.src || '';
+                const alt = (img.getAttribute('alt') || '').toLowerCase();
+                const cls = (img.className || '').toLowerCase();
+                const width = img.naturalWidth || img.width || 0;
+                const height = img.naturalHeight || img.height || 0;
+
+                if (!src) continue;
+                if (alt.includes('avatar') || alt.includes('profile') || alt.includes('logo') || alt.includes('icon')) continue;
+                if (cls.includes('avatar') || cls.includes('profile') || cls.includes('icon')) continue;
+                if (width < 128 && height < 128) continue;
+                if (seen.has(src)) continue;
+
+                seen.add(src);
+                urls.push(src);
+            }
+            return urls;
+        })()
+    `);
+}
+
+/**
+ * Wait for new images to appear after sending a prompt.
+ */
+export async function waitForChatGPTImages(page, beforeUrls, timeoutSeconds) {
+    const beforeSet = new Set(beforeUrls);
+    const pollIntervalSeconds = 3;
+    const maxPolls = Math.max(1, Math.ceil(timeoutSeconds / pollIntervalSeconds));
+    let lastUrls = [];
+    let stableCount = 0;
+
+    for (let i = 0; i < maxPolls; i++) {
+        await page.wait(i === 0 ? 3 : pollIntervalSeconds);
+
+        // Check if still generating
+        const generating = await isGenerating(page);
+        if (generating) continue;
+
+        const urls = (await getChatGPTVisibleImageUrls(page)).filter(url => !beforeSet.has(url));
+        if (urls.length === 0) continue;
+
+        const key = urls.join('\n');
+        const prevKey = lastUrls.join('\n');
+        if (key === prevKey) {
+            stableCount += 1;
+        } else {
+            lastUrls = urls;
+            stableCount = 1;
+        }
+
+        if (stableCount >= 2 || i === maxPolls - 1) {
+            return lastUrls;
+        }
+    }
+    return lastUrls;
+}
+
+/**
+ * Export images by URL: fetch from ChatGPT backend API and convert to base64 data URLs.
+ */
+export async function getChatGPTImageAssets(page, urls) {
+    const urlsJson = JSON.stringify(urls);
+    return await page.evaluate(`
+        (async (targetUrls) => {
+            const blobToDataUrl = (blob) => new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onloadend = () => resolve(String(reader.result || ''));
+                reader.onerror = () => reject(new Error('Failed to read blob'));
+                reader.readAsDataURL(blob);
+            });
+
+            const inferMime = (value, fallbackUrl) => {
+                if (value) return value;
+                const lower = String(fallbackUrl || '').toLowerCase();
+                if (lower.includes('.png')) return 'image/png';
+                if (lower.includes('.webp')) return 'image/webp';
+                if (lower.includes('.gif')) return 'image/gif';
+                return 'image/jpeg';
+            };
+
+            const results = [];
+
+            for (const targetUrl of targetUrls) {
+                let dataUrl = '';
+                let mimeType = 'image/jpeg';
+                let width = 0;
+                let height = 0;
+
+                // Try to find the img element for size info
+                const img = Array.from(document.querySelectorAll('img')).find(el =>
+                    (el.currentSrc || el.src || '') === targetUrl
+                );
+                if (img) {
+                    width = img.naturalWidth || img.width || 0;
+                    height = img.naturalHeight || img.height || 0;
+                }
+
+                try {
+                    if (String(targetUrl).startsWith('data:')) {
+                        dataUrl = String(targetUrl);
+                        mimeType = (String(targetUrl).match(/^data:([^;]+);/i) || [])[1] || 'image/png';
+                    } else {
+                        // Try to fetch via CORS from the page's origin
+                        const res = await fetch(targetUrl, { credentials: 'include' });
+                        if (res.ok) {
+                            const blob = await res.blob();
+                            mimeType = inferMime(blob.type, targetUrl);
+                            dataUrl = await blobToDataUrl(blob);
+                        }
+                    }
+                } catch (e) {
+                    // If fetch fails (CORS), try canvas approach via img element
+                }
+
+                // Fallback: draw img to canvas
+                if (!dataUrl && img && img instanceof HTMLImageElement) {
+                    try {
+                        const canvas = document.createElement('canvas');
+                        canvas.width = img.naturalWidth || img.width || 512;
+                        canvas.height = img.naturalHeight || img.height || 512;
+                        const ctx = canvas.getContext('2d');
+                        if (ctx) {
+                            ctx.drawImage(img, 0, 0);
+                            dataUrl = canvas.toDataURL('image/png');
+                            mimeType = 'image/png';
+                        }
+                    } catch (e) { }
+                }
+
+                if (dataUrl) {
+                    results.push({ url: String(targetUrl), dataUrl, mimeType, width, height });
+                }
+            }
+
+            return results;
+        })(${urlsJson})
+    `, urls);
+}

package/clis/{chatgpt → chatgpt-app}/ask.js

@@ -3,7 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ConfigError } from '@jackwener/opencli/errors';
 import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating } from './ax.js';
 export const askCommand = cli({
-    site: 'chatgpt',
+    site: 'chatgpt-app',
     name: 'ask',
     description: 'Send a prompt and wait for the AI response (send + wait + read)',
     domain: 'localhost',

package/clis/{chatgpt → chatgpt-app}/ax.js

@@ -121,11 +121,14 @@ let args = CommandLine.arguments
 let target = args.count > 1 ? args[1] : ""
 let needsLegacy = args.count > 2 && args[2] == "legacy"
 
-// Step 1: Click the "Options" button to open the popover
-guard let optionsBtn = findByDesc(win, "Options") else {
+// Step 1: Click the "Options" button to open the popover (support both English and Chinese UI)
+var optionsBtn: AXUIElement? = nil
+if let btn = findByDesc(win, "Options") { optionsBtn = btn }
+else if let btn = findByDesc(win, "选项") { optionsBtn = btn }
+guard let options = optionsBtn else {
     fputs("Could not find Options button\\n", stderr); exit(1)
 }
-press(optionsBtn)
+press(options)
 Thread.sleep(forTimeInterval: 0.8)
 
 // Step 2: Find the popover that appeared, search ONLY within it

package/clis/{chatgpt → chatgpt-app}/model.js

@@ -2,7 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ConfigError } from '@jackwener/opencli/errors';
 import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
 export const modelCommand = cli({
-    site: 'chatgpt',
+    site: 'chatgpt-app',
     name: 'model',
     description: 'Switch ChatGPT Desktop model/mode (auto, instant, thinking, 5.2-instant, 5.2-thinking)',
     domain: 'localhost',

package/clis/{chatgpt → chatgpt-app}/new.js

@@ -2,7 +2,7 @@ import { execSync } from 'node:child_process';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ConfigError, getErrorMessage } from '@jackwener/opencli/errors';
 export const newCommand = cli({
-    site: 'chatgpt',
+    site: 'chatgpt-app',
     name: 'new',
     description: 'Open a new chat in ChatGPT Desktop App',
     domain: 'localhost',

package/clis/{chatgpt → chatgpt-app}/read.js

@@ -3,7 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CommandExecutionError, ConfigError, getErrorMessage } from '@jackwener/opencli/errors';
 import { getVisibleChatMessages } from './ax.js';
 export const readCommand = cli({
-    site: 'chatgpt',
+    site: 'chatgpt-app',
     name: 'read',
     description: 'Read the last visible message from the focused ChatGPT Desktop window',
     domain: 'localhost',

package/clis/{chatgpt → chatgpt-app}/send.js

@@ -3,7 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 import { getErrorMessage } from '@jackwener/opencli/errors';
 import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
 export const sendCommand = cli({
-    site: 'chatgpt',
+    site: 'chatgpt-app',
     name: 'send',
     description: 'Send a message to the active ChatGPT Desktop App window',
     domain: 'localhost',

package/clis/{chatgpt → chatgpt-app}/status.js

@@ -2,7 +2,7 @@ import { execSync } from 'node:child_process';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CommandExecutionError, ConfigError } from '@jackwener/opencli/errors';
 export const statusCommand = cli({
-    site: 'chatgpt',
+    site: 'chatgpt-app',
     name: 'status',
     description: 'Check if ChatGPT Desktop App is running natively on macOS',
     domain: 'localhost',

package/clis/discord-app/delete.js

@@ -0,0 +1,114 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+function buildDeleteScript(messageId) {
+    return `(async () => {
+      try {
+          const messageId = ${JSON.stringify(messageId)};
+
+          // Find the message element by its ID attribute (format: chat-messages-{channelId}-{messageId})
+          const msgEl = document.querySelector('[id$="-' + messageId + '"]');
+          if (!msgEl) {
+              return { ok: false, message: 'Could not find a message with ID ' + messageId + ' in the current channel.' };
+          }
+
+          // Find the closest list item wrapper that Discord uses for messages
+          const listItem = msgEl.closest('[id^="chat-messages-"]') || msgEl;
+
+          // Hover over the message to reveal the action toolbar
+          listItem.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true }));
+          listItem.dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
+          await new Promise(r => setTimeout(r, 500));
+
+          // Look for the "More" button in the message toolbar
+          // Discord shows a toolbar with buttons when hovering over a message
+          const toolbar = listItem.querySelector('[class*="toolbar"]') ||
+              document.querySelector('[id^="message-actions-"]');
+          if (!toolbar) {
+              return { ok: false, message: 'Could not find the message action toolbar. Try scrolling so the message is fully visible.' };
+          }
+
+          const buttons = Array.from(toolbar.querySelectorAll('button, [role="button"], div[class*="button"]'));
+          const moreBtn = buttons.find(btn => {
+              const label = (btn.getAttribute('aria-label') || '').toLowerCase();
+              return label === 'more' || label.includes('more');
+          });
+          if (!moreBtn) {
+              return { ok: false, message: 'Could not find the "More" button on the message toolbar.' };
+          }
+
+          moreBtn.click();
+          await new Promise(r => setTimeout(r, 500));
+
+          // Find "Delete Message" in the context menu
+          const menuItems = Array.from(document.querySelectorAll('[role="menuitem"], [id*="message-actions"]'));
+          const deleteItem = menuItems.find(item => {
+              const text = (item.textContent || '').trim().toLowerCase();
+              return text.includes('delete message') || text === 'delete';
+          });
+
+          if (!deleteItem) {
+              // Close the menu by pressing Escape
+              document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+              return { ok: false, message: 'No "Delete Message" option found. You may not have permission to delete this message.' };
+          }
+
+          deleteItem.click();
+          await new Promise(r => setTimeout(r, 500));
+
+          // Confirm deletion in the modal dialog
+          const confirmBtn = document.querySelector('[type="submit"], button[class*="colorRed"], button[class*="danger"]');
+          if (!confirmBtn) {
+              return { ok: false, message: 'Delete confirmation dialog did not appear.' };
+          }
+
+          confirmBtn.click();
+          return { ok: true, message: 'Message ' + messageId + ' deleted successfully.' };
+      } catch (e) {
+          return { ok: false, message: e.toString() };
+      }
+  })()`;
+}
+
+cli({
+    site: 'discord-app',
+    name: 'delete',
+    description: 'Delete a message by its ID in the active Discord channel',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        {
+            name: 'message_id',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'The ID of the message to delete (visible via Developer Mode or the read command)',
+        },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for discord-app delete');
+        const messageId = kwargs.message_id;
+        if (!/^\d+$/.test(messageId)) {
+            throw new CommandExecutionError(
+                `Invalid message ID: "${messageId}". A Discord message ID is a numeric snowflake (e.g. 1234567890123456789).`
+            );
+        }
+        // Wait a moment for the chat to be fully loaded
+        await page.wait(0.5);
+        const result = await page.evaluate(buildDeleteScript(messageId));
+        if (result.ok) {
+            await page.wait(1);
+        }
+        return [{
+            status: result.ok ? 'success' : 'failed',
+            message: result.message,
+        }];
+    },
+});
+
+export const __test__ = {
+    buildDeleteScript,
+};

package/clis/douban/search.js

@@ -6,6 +6,7 @@ cli({
     description: '搜索豆瓣电影、图书或音乐',
     domain: 'search.douban.com',
     strategy: Strategy.COOKIE,
+    navigateBefore: false,
     args: [
         { name: 'type', default: 'movie', choices: ['movie', 'book', 'music'], help: '搜索类型（movie=电影, book=图书, music=音乐）' },
         { name: 'keyword', required: true, positional: true, help: '搜索关键词' },

package/clis/douban/search.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+
+describe('douban search command', () => {
+    it('skips default pre-navigation because the adapter handles navigation itself', () => {
+        const command = getRegistry().get('douban/search');
+        expect(command).toBeDefined();
+        expect(command?.navigateBefore).toBe(false);
+    });
+});

package/clis/douban/subject.js

@@ -1,18 +1,35 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { loadDoubanSubjectDetail } from './utils.js';
+
 cli({
     site: 'douban',
     name: 'subject',
-    description: '获取电影详情',
+    description: '获取豆瓣条目详情',
     domain: 'movie.douban.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    navigateBefore: false,
     args: [
-        { name: 'id', required: true, positional: true, help: '电影 ID' },
+        { name: 'id', required: true, positional: true, help: '豆瓣条目 ID' },
+        { name: 'type', default: 'movie', choices: ['movie', 'book'], help: '条目类型（movie=电影, book=图书）' },
     ],
     columns: [
         'id',
+        'type',
         'title',
+        'subtitle',
         'originalTitle',
+        'authors',
+        'translators',
+        'publisher',
+        'publishDate',
+        'publishYear',
+        'pageCount',
+        'binding',
+        'price',
+        'series',
+        'isbn10',
+        'isbn13',
         'year',
         'rating',
         'ratingCount',
@@ -24,95 +41,5 @@ cli({
         'summary',
         'url',
     ],
-    pipeline: [
-        { navigate: 'https://movie.douban.com/subject/${{ args.id }}' },
-        { evaluate: `(async () => {
-  const id = '\${{ args.id }}';
-
-  // Wait for page to load
-  await new Promise(r => setTimeout(r, 2000));
-
-  // Extract title - v:itemreviewed contains "中文名 OriginalName"
-  const titleEl = document.querySelector('span[property="v:itemreviewed"]');
-  const fullTitle = titleEl?.textContent?.trim() || '';
-
-  // Split title and originalTitle
-  // Douban format: "中文名 OriginalName" - split by first space that separates CJK from non-CJK
-  let title = fullTitle;
-  let originalTitle = '';
-  const titleMatch = fullTitle.match(/^([\\u4e00-\\u9fff\\u3000-\\u303f\\uff00-\\uffef]+(?:\\s*[\\u4e00-\\u9fff\\u3000-\\u303f\\uff00-\\uffef·：:！？]+)*)\\s+(.+)$/);
-  if (titleMatch) {
-    title = titleMatch[1].trim();
-    originalTitle = titleMatch[2].trim();
-  }
-
-  // Extract year
-  const yearEl = document.querySelector('.year');
-  const year = yearEl?.textContent?.trim().replace(/[()（）]/g, '') || '';
-
-  // Extract rating
-  const ratingEl = document.querySelector('strong[property="v:average"]');
-  const rating = parseFloat(ratingEl?.textContent || '0');
-
-  // Extract rating count
-  const ratingCountEl = document.querySelector('span[property="v:votes"]');
-  const ratingCount = parseInt(ratingCountEl?.textContent || '0', 10);
-
-  // Extract genres
-  const genreEls = document.querySelectorAll('span[property="v:genre"]');
-  const genres = Array.from(genreEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-
-  // Extract directors
-  const directorEls = document.querySelectorAll('a[rel="v:directedBy"]');
-  const directors = Array.from(directorEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-
-  // Extract casts
-  const castEls = document.querySelectorAll('a[rel="v:starring"]');
-  const casts = Array.from(castEls).slice(0, 5).map(el => el.textContent?.trim()).filter(Boolean);
-
-  // Extract info section for country and duration
-  const infoEl = document.querySelector('#info');
-  const infoText = infoEl?.textContent || '';
-
-  // Extract country/region from #info as list
-  let country = [];
-  const countryMatch = infoText.match(/制片国家\\/地区:\\s*([^\\n]+)/);
-  if (countryMatch) {
-    country = countryMatch[1].trim().split(/\\s*\\/\\s*/).filter(Boolean);
-  }
-
-  // Extract duration from #info as pure number in min
-  const durationEl = document.querySelector('span[property="v:runtime"]');
-  let durationRaw = durationEl?.textContent?.trim() || '';
-  if (!durationRaw) {
-    const durationMatch = infoText.match(/片长:\\s*([^\\n]+)/);
-    if (durationMatch) {
-      durationRaw = durationMatch[1].trim();
-    }
-  }
-  const durationNumMatch = durationRaw.match(/(\\d+)/);
-  const duration = durationNumMatch ? parseInt(durationNumMatch[1], 10) : null;
-
-  // Extract summary
-  const summaryEl = document.querySelector('span[property="v:summary"]');
-  const summary = summaryEl?.textContent?.trim() || '';
-
-  return [{
-    id,
-    title,
-    originalTitle,
-    year,
-    rating,
-    ratingCount,
-    genres,
-    directors,
-    casts,
-    country,
-    duration,
-    summary: summary.substring(0, 200),
-    url: \`https://movie.douban.com/subject/\${id}\`
-  }];
-})()
-` },
-    ],
+    func: async (page, args) => [await loadDoubanSubjectDetail(page, args.id, args.type)],
 });

package/clis/douban/subject.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './subject.js';
+
+describe('douban subject command', () => {
+    it('skips default pre-navigation because the adapter handles subject navigation itself', () => {
+        const command = getRegistry().get('douban/subject');
+        expect(command).toBeDefined();
+        expect(command?.navigateBefore).toBe(false);
+    });
+});