@jackwener/opencli 1.3.2 → 1.4.0

package/src/snapshotFormatter.ts

@@ -1,21 +1,14 @@
 /**
  * Aria snapshot formatter: parses Playwright MCP snapshot text into clean format.
  *
- * Multi-pass pipeline:
- * 1. Parse & filter: strip annotations, metadata, noise roles, ads, decorators
- * 2. Deduplicate: generic/text child matching parent label
- * 3. Deduplicate: heading + link with identical labels
- * 4. Deduplicate: nested identical links
- * 5. Prune: empty containers (iterative bottom-up)
- * 6. Collapse: single-child containers
+ * 4-pass pipeline:
+ * 1. Parse & filter: strip annotations, metadata, noise, ads, boilerplate subtrees
+ * 2. Deduplicate: generic/text parent match, heading+link, nested identical links
+ * 3. Prune: empty containers (iterative bottom-up)
+ * 4. Collapse: single-child containers
  */
 
-export interface FormatOptions {
-  interactive?: boolean;
-  compact?: boolean;
-  maxDepth?: number;
-  maxTextLength?: number;
-}
+import type { SnapshotOptions } from './types.js';
 
 const DEFAULT_MAX_TEXT_LENGTH = 200;
 
@@ -199,19 +192,18 @@ interface Entry {
   trailingText: string;
   isInteractive: boolean;
   isLandmark: boolean;
-  isSubtreeSkip: boolean; // ad nodes or boilerplate — skip entire subtree
 }
 
-export function formatSnapshot(raw: string, opts: FormatOptions = {}): string {
+export function formatSnapshot(raw: string, opts: SnapshotOptions = {}): string {
   if (!raw || typeof raw !== 'string') return '';
 
   const maxTextLen = opts.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
   const lines = raw.split('\n');
 
-  // === Pass 1: Parse, filter, and collect entries ===
-  const entries: Entry[] = [];
+  // === Pass 1: Parse, filter, and collect entries (merged with ad/boilerplate subtree skip) ===
+  const parsed: Entry[] = [];
   let refCounter = 0;
-  let skipUntilDepth = -1; // When >= 0, skip all nodes at depth > this value
+  let skipUntilDepth = -1;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -220,148 +212,88 @@ export function formatSnapshot(raw: string, opts: FormatOptions = {}): string {
     const indent = line.length - line.trimStart().length;
     const depth = Math.floor(indent / 2);
 
-    // If we're in a subtree skip zone, check depth
+    // Subtree skip zone (noise roles, ads, boilerplate)
     if (skipUntilDepth >= 0) {
-      if (depth > skipUntilDepth) continue; // still inside subtree
-      skipUntilDepth = -1; // exited subtree
+      if (depth > skipUntilDepth) continue;
+      skipUntilDepth = -1;
     }
 
     let content = line.trimStart();
-
-    // Strip leading "- "
-    if (content.startsWith('- ')) {
-      content = content.slice(2);
-    }
-
-    // Skip metadata lines
+    if (content.startsWith('- ')) content = content.slice(2);
     if (isMetadataLine(content)) continue;
-
-    // Apply maxDepth filter
     if (opts.maxDepth !== undefined && depth > opts.maxDepth) continue;
 
     const { role, text, hasText, trailingText } = parseLine(content);
 
-    // Skip noise nodes
     if (isNoiseNode(role, hasText, text, trailingText)) continue;
 
-    // Skip subtree noise roles (contentinfo footer, etc.) — skip entire subtree
-    if (SUBTREE_NOISE_ROLES.has(role)) {
-      skipUntilDepth = depth;
-      continue;
-    }
+    // Subtree noise roles (contentinfo footer, etc.)
+    if (SUBTREE_NOISE_ROLES.has(role)) { skipUntilDepth = depth; continue; }
 
-    // Strip annotations
-    content = stripAnnotations(content);
+    // Ads and boilerplate — skip entire subtree (merged from old Pass 2)
+    if (isAdNode(text, trailingText) || isBoilerplateNode(text)) { skipUntilDepth = depth; continue; }
 
-    // Check if node should trigger subtree skip (ads, boilerplate)
-    const isSubtreeSkip = isAdNode(text, trailingText) || isBoilerplateNode(text);
+    content = stripAnnotations(content);
 
-    // Interactive mode filter
     const isInteractive = INTERACTIVE_ROLES.has(role);
     const isLandmark = LANDMARK_ROLES.has(role);
-
     if (opts.interactive && !isInteractive && !isLandmark && !hasText) continue;
 
-    // Compact mode
     if (opts.compact) {
-      content = content
-        .replace(/\s*\[.*?\]\s*/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
+      content = content.replace(/\s*\[.*?\]\s*/g, ' ').replace(/\s+/g, ' ').trim();
     }
-
-    // Text truncation
     if (maxTextLen > 0 && content.length > maxTextLen) {
       content = content.slice(0, maxTextLen) + '…';
     }
-
-    // Assign refs to interactive elements
     if (isInteractive) {
       refCounter++;
       content = `[@${refCounter}] ${content}`;
     }
 
-    entries.push({ depth, content, role, text, trailingText, isInteractive, isLandmark, isSubtreeSkip });
-  }
-
-  // === Pass 2: Remove subtree-skip nodes (ads, boilerplate, contentinfo) ===
-  let noAds: Entry[] = [];
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    if (entry.isSubtreeSkip) {
-      const skipDepth = entry.depth;
-      i++;
-      while (i < entries.length && entries[i].depth > skipDepth) {
-        i++;
-      }
-      i--;
-      continue;
-    }
-    noAds.push(entry);
+    parsed.push({ depth, content, role, text, trailingText, isInteractive, isLandmark });
   }
 
-  // === Pass 3: Deduplicate child generic/text matching parent label ===
-  let deduped: Entry[] = [];
-  for (let i = 0; i < noAds.length; i++) {
-    const entry = noAds[i];
+  // === Pass 2: Deduplicate (merged: generic/text parent match + heading+link + nested links) ===
+  const deduped: Entry[] = [];
+  for (let i = 0; i < parsed.length; i++) {
+    const entry = parsed[i];
 
+    // Dedup: generic/text child matching parent label
     if (entry.role === 'generic' || entry.role === 'text') {
       let parent: Entry | undefined;
       for (let j = deduped.length - 1; j >= 0; j--) {
-        if (deduped[j].depth < entry.depth) {
-          parent = deduped[j];
-          break;
-        }
+        if (deduped[j].depth < entry.depth) { parent = deduped[j]; break; }
         if (deduped[j].depth === entry.depth) break;
       }
-
       if (parent) {
         const childText = entry.trailingText || entry.text;
-        if (childText && parent.text && childText === parent.text) {
-          continue;
-        }
+        if (childText && parent.text && childText === parent.text) continue;
       }
     }
 
-    deduped.push(entry);
-  }
-
-  // === Pass 4: Deduplicate heading + child link with identical label ===
-  // Pattern: heading "Title": → link "Title": (same text) → skip the link
-  const deduped2: Entry[] = [];
-  for (let i = 0; i < deduped.length; i++) {
-    const entry = deduped[i];
-
+    // Dedup: heading + child link with identical label
     if (entry.role === 'heading' && entry.text) {
-      const next = deduped[i + 1];
+      const next = parsed[i + 1];
       if (next && next.role === 'link' && next.text === entry.text && next.depth === entry.depth + 1) {
-        // Keep the heading, skip the link. But preserve link's children re-parented.
-        deduped2.push(entry);
-        i++; // skip the link
+        deduped.push(entry);
+        i++; // skip the link, preserve its children
         continue;
       }
     }
 
-    deduped2.push(entry);
-  }
-
-  // === Pass 5: Deduplicate nested identical links ===
-  const deduped3: Entry[] = [];
-  for (let i = 0; i < deduped2.length; i++) {
-    const entry = deduped2[i];
-
+    // Dedup: nested identical links (skip parent, keep child)
     if (entry.role === 'link' && entry.text) {
-      const next = deduped2[i + 1];
+      const next = parsed[i + 1];
       if (next && next.role === 'link' && next.text === entry.text && next.depth === entry.depth + 1) {
-        continue; // Skip parent, keep child
+        continue;
       }
     }
 
-    deduped3.push(entry);
+    deduped.push(entry);
   }
 
-  // === Pass 6: Iteratively prune empty containers (bottom-up) ===
-  let current = deduped3;
+  // === Pass 3: Iteratively prune empty containers (bottom-up) ===
+  let current = deduped;
   let changed = true;
   while (changed) {
     changed = false;
@@ -372,22 +304,16 @@ export function formatSnapshot(raw: string, opts: FormatOptions = {}): string {
         let hasChildren = false;
         for (let j = i + 1; j < current.length; j++) {
           if (current[j].depth <= entry.depth) break;
-          if (current[j].depth > entry.depth) {
-            hasChildren = true;
-            break;
-          }
-        }
-        if (!hasChildren) {
-          changed = true;
-          continue;
+          if (current[j].depth > entry.depth) { hasChildren = true; break; }
         }
+        if (!hasChildren) { changed = true; continue; }
       }
       next.push(entry);
     }
     current = next;
   }
 
-  // === Pass 7: Collapse single-child containers ===
+  // === Pass 4: Collapse single-child containers ===
   const collapsed: Entry[] = [];
   for (let i = 0; i < current.length; i++) {
     const entry = current[i];
@@ -408,17 +334,13 @@ export function formatSnapshot(raw: string, opts: FormatOptions = {}): string {
         let hasGrandchildren = false;
         for (let j = childIdx + 1; j < current.length; j++) {
           if (current[j].depth <= child.depth) break;
-          if (current[j].depth > child.depth) {
-            hasGrandchildren = true;
-            break;
-          }
+          if (current[j].depth > child.depth) { hasGrandchildren = true; break; }
         }
 
         if (!hasGrandchildren) {
-          const mergedContent = entry.content.replace(/:$/, '') + ' > ' + child.content;
           collapsed.push({
             ...entry,
-            content: mergedContent,
+            content: entry.content.replace(/:$/, '') + ' > ' + child.content,
             role: child.role,
             text: child.text,
             trailingText: child.trailingText,

package/src/utils.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared utility functions used across the codebase.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/** Type guard: checks if a value is a non-null, non-array object. */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** Simple async concurrency limiter. */
+export async function mapConcurrent<T, R>(
+  items: T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let index = 0;
+
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+/** Save a base64-encoded string to a file, creating parent directories as needed. */
+export async function saveBase64ToFile(base64: string, filePath: string): Promise<void> {
+  const dir = path.dirname(filePath);
+  await fs.promises.mkdir(dir, { recursive: true });
+  await fs.promises.writeFile(filePath, Buffer.from(base64, 'base64'));
+}

package/src/validate.ts

@@ -6,10 +6,10 @@ import { getErrorMessage } from './errors.js';
 
 /** All recognized pipeline step names */
 const KNOWN_STEP_NAMES = new Set([
-  'navigate', 'click', 'type', 'wait', 'press', 'snapshot', 'scroll',
+  'navigate', 'click', 'type', 'wait', 'press', 'snapshot',
   'fetch', 'evaluate',
   'select', 'map', 'filter', 'sort', 'limit',
-  'intercept', 'tap',
+  'intercept', 'tap', 'download',
 ]);
 
 export interface FileValidationResult {
@@ -34,10 +34,7 @@ interface ValidatedYamlCliDefinition {
   args?: Record<string, unknown>;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
+import { isRecord } from './utils.js';
 
 
 export function validateClisWithTarget(dirs: string[], target?: string): ValidationReport {

package/src/yaml-schema.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared YAML CLI definition types.
+ * Used by both discovery.ts (runtime) and build-manifest.ts (build-time).
+ */
+
+export interface YamlArgDefinition {
+  type?: string;
+  default?: unknown;
+  required?: boolean;
+  positional?: boolean;
+  description?: string;
+  help?: string;
+  choices?: string[];
+}
+
+export interface YamlCliDefinition {
+  site?: string;
+  name?: string;
+  description?: string;
+  domain?: string;
+  strategy?: string;
+  browser?: boolean;
+  args?: Record<string, YamlArgDefinition>;
+  columns?: string[];
+  pipeline?: Record<string, unknown>[];
+  timeout?: number;
+  navigateBefore?: boolean | string;
+}

package/tests/e2e/browser-auth.test.ts

@@ -113,6 +113,31 @@ describe('login-required commands — graceful failure', () => {
     await expectGracefulAuthFailure(['xiaohongshu', 'notifications', '--limit', '3', '-f', 'json'], 'xiaohongshu notifications');
   }, 60_000);
 
+  // ── pixiv (requires login) ──
+  it('pixiv ranking fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['pixiv', 'ranking', '--limit', '3', '-f', 'json'], 'pixiv ranking');
+  }, 60_000);
+
+  it('pixiv search fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['pixiv', 'search', '初音ミク', '--limit', '3', '-f', 'json'], 'pixiv search');
+  }, 60_000);
+
+  it('pixiv user fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['pixiv', 'user', '11', '-f', 'json'], 'pixiv user');
+  }, 60_000);
+
+  it('pixiv illusts fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['pixiv', 'illusts', '11', '--limit', '3', '-f', 'json'], 'pixiv illusts');
+  }, 60_000);
+
+  it('pixiv detail fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['pixiv', 'detail', '123456', '-f', 'json'], 'pixiv detail');
+  }, 60_000);
+
+  it('pixiv download fails gracefully without login', async () => {
+    await expectGracefulAuthFailure(['pixiv', 'download', '123456', '--output', '/tmp/pixiv-e2e-test', '-f', 'json'], 'pixiv download');
+  }, 60_000);
+
   // ── yollomi (requires login session) ──
   it('yollomi generate fails gracefully without login', async () => {
     await expectGracefulAuthFailure(['yollomi', 'generate', 'a cute cat', '--no-download', '-f', 'json'], 'yollomi generate');

package/tests/e2e/plugin-management.test.ts

@@ -0,0 +1,137 @@
+/**
+ * E2E integration tests for plugin management commands.
+ * Uses a real GitHub plugin (opencli-plugin-hot-digest) to verify the full
+ * install → list → update → uninstall lifecycle in an isolated HOME.
+ */
+
+import { describe, it, expect, afterAll } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { runCli, parseJsonOutput } from './helpers.js';
+
+const TEST_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-plugin-e2e-'));
+const OPENCLI_HOME = path.join(TEST_HOME, '.opencli');
+const PLUGINS_DIR = path.join(OPENCLI_HOME, 'plugins');
+const PLUGIN_SOURCE = 'github:ByteYue/opencli-plugin-hot-digest';
+const PLUGIN_NAME = 'hot-digest';
+const PLUGIN_DIR = path.join(PLUGINS_DIR, PLUGIN_NAME);
+const LOCK_FILE = path.join(OPENCLI_HOME, 'plugins.lock.json');
+
+function runPluginCli(
+  args: string[],
+  opts: { timeout?: number; env?: Record<string, string> } = {},
+) {
+  return runCli(args, {
+    ...opts,
+    env: {
+      HOME: TEST_HOME,
+      USERPROFILE: TEST_HOME,
+      ...opts.env,
+    },
+  });
+}
+
+describe('plugin management E2E', () => {
+  afterAll(() => {
+    fs.rmSync(TEST_HOME, { recursive: true, force: true });
+  });
+
+  // ── plugin list (empty) ──
+  it('plugin list shows "No plugins installed" when none exist', async () => {
+    const { stdout, code } = await runPluginCli(['plugin', 'list']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('No plugins installed');
+  });
+
+  // ── plugin install ──
+  it('plugin install clones and sets up a real plugin', async () => {
+    const { stdout, code } = await runPluginCli(['plugin', 'install', PLUGIN_SOURCE], {
+      timeout: 60_000,
+    });
+    expect(code).toBe(0);
+    expect(stdout).toContain('installed successfully');
+    expect(stdout).toContain(PLUGIN_NAME);
+
+    // Verify the plugin directory was created
+    expect(fs.existsSync(PLUGIN_DIR)).toBe(true);
+
+    // Verify lock file was updated
+    const lock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+    expect(lock[PLUGIN_NAME]).toBeDefined();
+    expect(lock[PLUGIN_NAME].commitHash).toBeTruthy();
+    expect(lock[PLUGIN_NAME].source).toContain('opencli-plugin-hot-digest');
+    expect(lock[PLUGIN_NAME].installedAt).toBeTruthy();
+  }, 60_000);
+
+  // ── plugin list (after install) ──
+  it('plugin list shows the installed plugin', async () => {
+    const { stdout, code } = await runPluginCli(['plugin', 'list']);
+    expect(code).toBe(0);
+    expect(stdout).toContain(PLUGIN_NAME);
+  });
+
+  it('plugin list -f json returns structured data', async () => {
+    const { stdout, code } = await runPluginCli(['plugin', 'list', '-f', 'json']);
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+
+    const plugin = data.find((p: any) => p.name === PLUGIN_NAME);
+    expect(plugin).toBeDefined();
+    expect(plugin.name).toBe(PLUGIN_NAME);
+    expect(Array.isArray(plugin.commands)).toBe(true);
+    expect(plugin.commands.length).toBeGreaterThan(0);
+  });
+
+  // ── plugin update ──
+  it('plugin update succeeds on an installed plugin', async () => {
+    const { stdout, code } = await runPluginCli(['plugin', 'update', PLUGIN_NAME], {
+      timeout: 30_000,
+    });
+    expect(code).toBe(0);
+    expect(stdout).toContain('updated successfully');
+
+    // Verify lock file has updatedAt
+    const lock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+    expect(lock[PLUGIN_NAME].updatedAt).toBeTruthy();
+  }, 30_000);
+
+  // ── plugin uninstall ──
+  it('plugin uninstall removes the plugin', async () => {
+    const { stdout, code } = await runPluginCli(['plugin', 'uninstall', PLUGIN_NAME]);
+    expect(code).toBe(0);
+    expect(stdout).toContain('uninstalled');
+
+    // Verify directory was removed
+    expect(fs.existsSync(PLUGIN_DIR)).toBe(false);
+
+    // Verify lock entry was removed
+    const lock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+    expect(lock[PLUGIN_NAME]).toBeUndefined();
+  });
+
+  // ── error paths ──
+  it('plugin install rejects invalid source', async () => {
+    const { stderr, code } = await runPluginCli(['plugin', 'install', 'invalid-source-format']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('Invalid plugin source');
+  });
+
+  it('plugin uninstall rejects non-existent plugin', async () => {
+    const { stderr, code } = await runPluginCli(['plugin', 'uninstall', '__nonexistent_plugin_xyz__']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('not installed');
+  });
+
+  it('plugin update rejects non-existent plugin', async () => {
+    const { stderr, code } = await runPluginCli(['plugin', 'update', '__nonexistent_plugin_xyz__']);
+    expect(code).toBe(1);
+  });
+
+  it('plugin update without name or --all shows error', async () => {
+    const { stderr, code } = await runPluginCli(['plugin', 'update']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('specify a plugin name');
+  });
+});

package/tests/e2e/public-commands.test.ts

@@ -16,7 +16,8 @@ function isExpectedChineseSiteRestriction(code: number, stderr: string): boolean
 
 function isExpectedApplePodcastsRestriction(code: number, stderr: string): boolean {
   if (code === 0) return false;
-  return /Error \[FETCH_ERROR\]: (Charts API HTTP \d+|Unable to reach Apple Podcasts charts)/.test(stderr);
+  return /Error \[FETCH_ERROR\]: (Charts API HTTP \d+|Unable to reach Apple Podcasts charts)/.test(stderr)
+    || stderr === ''; // timeout killed the process before any output
 }
 
 function isExpectedGoogleRestriction(code: number, stderr: string): boolean {
@@ -488,4 +489,36 @@ describe('public commands E2E', () => {
     expect(data.length).toBeGreaterThan(0);
     expect(data.every((d: any) => d.type === 'image')).toBe(true);
   }, 30_000);
+
+  // ── dictionary (public API, browser: false) ──
+  it('dictionary search returns word definitions', async () => {
+    const { stdout, code } = await runCli(['dictionary', 'search', 'serendipity', '-f', 'json']);
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('word', 'serendipity');
+    expect(data[0]).toHaveProperty('phonetic');
+    expect(data[0]).toHaveProperty('definition');
+  }, 30_000);
+
+  it('dictionary synonyms returns synonyms', async () => {
+    const { stdout, code } = await runCli(['dictionary', 'synonyms', 'serendipity', '-f', 'json']);
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('word', 'serendipity');
+    expect(data[0]).toHaveProperty('synonyms');
+  }, 30_000);
+
+  it('dictionary examples returns examples', async () => {
+    const { stdout, code } = await runCli(['dictionary', 'examples', 'perfect', '-f', 'json']);
+    expect(code).toBe(0);
+    const data = parseJsonOutput(stdout);
+    expect(Array.isArray(data)).toBe(true);
+    expect(data.length).toBeGreaterThanOrEqual(1);
+    expect(data[0]).toHaveProperty('word', 'perfect');
+    expect(data[0]).toHaveProperty('example');
+  }, 30_000);
 });

package/vitest.config.ts

@@ -7,19 +7,37 @@ export default defineConfig({
         test: {
           name: 'unit',
           include: ['src/**/*.test.ts'],
+          exclude: ['src/clis/**/*.test.ts'],
           // Run unit tests before e2e tests to avoid project-level contention in CI.
           sequence: {
             groupOrder: 0,
           },
         },
       },
+      {
+        test: {
+          name: 'adapter',
+          include: [
+            'src/clis/zhihu/**/*.test.ts',
+            'src/clis/twitter/**/*.test.ts',
+            'src/clis/reddit/**/*.test.ts',
+            'src/clis/bilibili/**/*.test.ts',
+            'src/clis/linkedin/**/*.test.ts',
+            'src/clis/grok/**/*.test.ts',
+            'src/clis/pixiv/**/*.test.ts',
+          ],
+          sequence: {
+            groupOrder: 1,
+          },
+        },
+      },
       {
         test: {
           name: 'e2e',
           include: ['tests/**/*.test.ts'],
           maxWorkers: 2,
           sequence: {
-            groupOrder: 1,
+            groupOrder: 2,
           },
         },
       },

package/.github/workflows/pkg-pr-new.yml

@@ -1,30 +0,0 @@
-name: Publish Any Commit
-
-on:
-  push:
-    branches: [main, dev]
-  pull_request:
-    branches: [main, dev]
-
-permissions: {}
-
-jobs:
-  publish:
-    if: ${{ vars.PKG_PR_NEW_ENABLED == 'true' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '22'
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build
-
-      - name: Publish to pkg.pr.new
-        run: npx pkg-pr-new publish

package/dist/clis/douban/shared.d.ts

@@ -1,4 +0,0 @@
-import type { IPage } from '../../types.js';
-export declare function loadDoubanBookHot(page: IPage, limit: number): Promise<any[]>;
-export declare function loadDoubanMovieHot(page: IPage, limit: number): Promise<any[]>;
-export declare function searchDouban(page: IPage, type: string, keyword: string, limit: number): Promise<any[]>;