@sovovs/bycli 2.1.28 → 2.1.29

package/cli-manifest.json

@@ -11320,6 +11320,221 @@
     "modulePath": "gitee/user.js",
     "sourceFile": "gitee/user.js"
   },
+  {
+    "site": "github",
+    "name": "repo",
+    "description": "Single-repository metadata including the true watch count",
+    "access": "read",
+    "domain": "api.github.com",
+    "strategy": "public",
+    "browser": false,
+    "args": [
+      {
+        "name": "repo",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Repository as \"owner/repo\" (the full_name column from search) or its github.com URL"
+      }
+    ],
+    "columns": [
+      "full_name",
+      "stars",
+      "forks",
+      "watchers",
+      "open_issues",
+      "language",
+      "description",
+      "license",
+      "topics",
+      "homepage",
+      "default_branch",
+      "archived",
+      "is_fork",
+      "size_kb",
+      "created",
+      "pushed",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "github/repo.js",
+    "sourceFile": "github/repo.js"
+  },
+  {
+    "site": "github",
+    "name": "search",
+    "description": "Search GitHub repositories by stars, forks, watchers, language, topic and more",
+    "access": "read",
+    "domain": "api.github.com",
+    "strategy": "public",
+    "browser": false,
+    "args": [
+      {
+        "name": "query",
+        "type": "str",
+        "required": false,
+        "positional": true,
+        "help": "Free-text keyword; optional when at least one filter flag is given"
+      },
+      {
+        "name": "stars",
+        "type": "str",
+        "required": false,
+        "help": "Star count filter: \"5000\" (>=), \">10000\", \"<500\", \"1000..5000\""
+      },
+      {
+        "name": "forks",
+        "type": "str",
+        "required": false,
+        "help": "Fork count filter, same syntax as --stars"
+      },
+      {
+        "name": "watchers",
+        "type": "str",
+        "required": false,
+        "help": "Watch count filter, same syntax as --stars (client-side; costs 1 API call per scanned repo)"
+      },
+      {
+        "name": "language",
+        "type": "str",
+        "required": false,
+        "help": "Primary language, comma-separated for multiple (e.g. \"rust,go\")"
+      },
+      {
+        "name": "topic",
+        "type": "str",
+        "required": false,
+        "help": "Repository topic, comma-separated for multiple (e.g. \"cli,devtools\")"
+      },
+      {
+        "name": "license",
+        "type": "str",
+        "required": false,
+        "help": "License keyword (e.g. \"mit\", \"apache-2.0\")"
+      },
+      {
+        "name": "size",
+        "type": "str",
+        "required": false,
+        "help": "Repo size in KB: \"1000\" (>=), \"<500\", \"100..1000\""
+      },
+      {
+        "name": "pushed",
+        "type": "str",
+        "required": false,
+        "help": "Last push date: \"2026-01-01\" (>=), \">2026-01-01\", \"2025-01-01..2026-01-01\""
+      },
+      {
+        "name": "created",
+        "type": "str",
+        "required": false,
+        "help": "Creation date, same syntax as --pushed"
+      },
+      {
+        "name": "issues",
+        "type": "str",
+        "required": false,
+        "help": "Good-first-issue count filter, same syntax as --stars"
+      },
+      {
+        "name": "owner",
+        "type": "str",
+        "required": false,
+        "help": "Restrict to owners/orgs, comma-separated (e.g. \"facebook,vercel\")"
+      },
+      {
+        "name": "in",
+        "type": "str",
+        "required": false,
+        "help": "Restrict free-text match to: name, description, readme, topics (comma-separated)"
+      },
+      {
+        "name": "include-forks",
+        "type": "bool",
+        "default": false,
+        "required": false,
+        "help": "Include forked repos (GitHub excludes them by default)"
+      },
+      {
+        "name": "include-archived",
+        "type": "bool",
+        "default": false,
+        "required": false,
+        "help": "Include archived repos"
+      },
+      {
+        "name": "sort",
+        "type": "str",
+        "default": "best-match",
+        "required": false,
+        "help": "Ranking dimension; \"watchers\" sorts client-side and enriches every scanned row",
+        "choices": [
+          "best-match",
+          "stars",
+          "forks",
+          "watchers",
+          "updated",
+          "help-wanted-issues"
+        ]
+      },
+      {
+        "name": "order",
+        "type": "str",
+        "default": "desc",
+        "required": false,
+        "help": "Sort direction",
+        "choices": [
+          "desc",
+          "asc"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 20,
+        "required": false,
+        "help": "Max results (1-100)"
+      },
+      {
+        "name": "page",
+        "type": "int",
+        "default": 1,
+        "required": false,
+        "help": "Result page; GitHub never serves past result 1000"
+      },
+      {
+        "name": "scan",
+        "type": "int",
+        "default": 30,
+        "required": false,
+        "help": "Candidate pool size when filtering/sorting by watchers (1-100, one API call each)"
+      },
+      {
+        "name": "with-watchers",
+        "type": "bool",
+        "default": false,
+        "required": false,
+        "help": "Add the real watch count column without filtering on it"
+      }
+    ],
+    "columns": [
+      "rank",
+      "full_name",
+      "stars",
+      "forks",
+      "watchers",
+      "language",
+      "description",
+      "license",
+      "topics",
+      "open_issues",
+      "pushed",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "github/search.js",
+    "sourceFile": "github/search.js"
+  },
   {
     "site": "google",
     "name": "news",
@@ -14863,6 +15078,87 @@
     "modulePath": "jira/search.js",
     "sourceFile": "jira/search.js"
   },
+  {
+    "site": "juejin",
+    "name": "search",
+    "description": "掘金搜索，支持综合/文章/课程/标签/用户维度与综合/最新/最热排序",
+    "access": "read",
+    "domain": "api.juejin.cn",
+    "strategy": "public",
+    "browser": false,
+    "args": [
+      {
+        "name": "query",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "搜索关键词"
+      },
+      {
+        "name": "type",
+        "type": "str",
+        "default": "all",
+        "required": false,
+        "help": "结果类型：all(综合) / article(文章) / course(课程) / tag(标签) / user(用户)",
+        "choices": [
+          "all",
+          "article",
+          "course",
+          "tag",
+          "user"
+        ]
+      },
+      {
+        "name": "sort",
+        "type": "str",
+        "default": "relevance",
+        "required": false,
+        "help": "排序：relevance(综合) / newest(最新优先) / hottest(最热优先)",
+        "choices": [
+          "relevance",
+          "newest",
+          "hottest"
+        ]
+      },
+      {
+        "name": "period",
+        "type": "str",
+        "default": "all",
+        "required": false,
+        "help": "时间范围：all(不限) / day(最近一天) / week(最近一周) / month3(最近三月)",
+        "choices": [
+          "all",
+          "day",
+          "week",
+          "month3"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 20,
+        "required": false,
+        "help": "返回条数 (max 200)"
+      }
+    ],
+    "columns": [
+      "rank",
+      "kind",
+      "id",
+      "title",
+      "author",
+      "views",
+      "likes",
+      "comments",
+      "hot_index",
+      "published_at",
+      "url",
+      "extra"
+    ],
+    "type": "js",
+    "modulePath": "juejin/search.js",
+    "sourceFile": "juejin/search.js"
+  },
   {
     "site": "ke",
     "name": "chengjiao",

package/clis/github/repo.js

@@ -0,0 +1,47 @@
+// github repo — single-repository metadata from `/repos/{owner}/{repo}`.
+//
+// Pairs with `github search`: the `full_name` column from a search row goes
+// straight into this command's positional argument. This is also the only
+// endpoint that reports a true watch count (`subscribers_count`); the search
+// index does not carry it.
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { GITHUB_API, githubFetch, requireFullName } from './utils.js';
+
+cli({
+    site: 'github',
+    name: 'repo',
+    access: 'read',
+    description: 'Single-repository metadata including the true watch count',
+    domain: 'api.github.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'repo', positional: true, required: true, help: 'Repository as "owner/repo" (the full_name column from search) or its github.com URL' },
+    ],
+    columns: ['full_name', 'stars', 'forks', 'watchers', 'open_issues', 'language', 'description', 'license', 'topics', 'homepage', 'default_branch', 'archived', 'is_fork', 'size_kb', 'created', 'pushed', 'url'],
+    func: async (args) => {
+        const fullName = requireFullName(args.repo);
+        const r = await githubFetch(`${GITHUB_API}/repos/${fullName}`, `github repo ${fullName}`);
+        return [{
+            full_name: String(r?.full_name ?? fullName),
+            stars: r?.stargazers_count != null ? Number(r.stargazers_count) : null,
+            forks: r?.forks_count != null ? Number(r.forks_count) : null,
+            // `subscribers_count` is the watch count. `watchers_count` on this
+            // payload is a legacy alias for the star count — do not use it.
+            watchers: r?.subscribers_count != null ? Number(r.subscribers_count) : null,
+            open_issues: r?.open_issues_count != null ? Number(r.open_issues_count) : null,
+            language: String(r?.language ?? ''),
+            description: String(r?.description ?? '').trim(),
+            license: String(r?.license?.spdx_id ?? ''),
+            topics: Array.isArray(r?.topics) ? r.topics.join(', ') : '',
+            homepage: String(r?.homepage ?? ''),
+            default_branch: String(r?.default_branch ?? ''),
+            archived: Boolean(r?.archived),
+            is_fork: Boolean(r?.fork),
+            size_kb: r?.size != null ? Number(r.size) : null,
+            created: String(r?.created_at ?? '').slice(0, 10),
+            pushed: String(r?.pushed_at ?? '').slice(0, 10),
+            url: String(r?.html_url ?? `https://github.com/${fullName}`),
+        }];
+    },
+});

package/clis/github/search.js

@@ -0,0 +1,281 @@
+// github search — multi-dimension repository search over the public GitHub
+// REST API (`/search/repositories`).
+//
+// Dimensions map to GitHub search qualifiers server-side (stars, forks,
+// language, topic, license, size, created, pushed, owner) so filtering happens
+// before results are paged.
+//
+// The watch dimension is the exception. GitHub's search index has NO watcher
+// qualifier — `watchers:`/`followers:` are aliases for the star count — and
+// search rows report `watchers_count` as a mirror of `stargazers_count`. The
+// real watch count only exists as `subscribers_count` on the repo endpoint, so
+// `--watchers` / `--sort watchers` scan a candidate pool and enrich each row
+// with one extra API call apiece. See `--scan`.
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
+import {
+    GITHUB_API,
+    buildDateQualifier,
+    buildRangeQualifier,
+    githubFetch,
+    requireBoundedInt,
+} from './utils.js';
+
+const MAX_LIMIT = 100; // GitHub caps per_page at 100 for search
+const MAX_SCAN = 100;
+const ENRICH_CONCURRENCY = 5;
+// GitHub's search index never returns past result 1000, regardless of per_page.
+const MAX_SEARCH_WINDOW = 1000;
+
+/** Server-side sorts GitHub understands; `best-match` means "omit the param". */
+const SERVER_SORTS = new Set(['stars', 'forks', 'updated', 'help-wanted-issues']);
+
+/** Split a comma-separated arg into trimmed, non-empty terms. */
+function splitTerms(value) {
+    return String(value ?? '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+
+/**
+ * Quote a qualifier value when it contains whitespace, so
+ * `--license "MIT License"` doesn't split into two qualifiers.
+ */
+function quoteIfNeeded(value) {
+    return /\s/.test(value) ? `"${value}"` : value;
+}
+
+/**
+ * Turn a `--watchers` value into a local predicate.
+ *
+ * Reuses `buildRangeQualifier` for validation so the accepted syntax can't
+ * drift from the server-side range flags.
+ */
+export function compileWatchersPredicate(value) {
+    const qualifier = buildRangeQualifier('watchers', value);
+    const expr = qualifier.slice('watchers:'.length);
+    let m;
+    if ((m = expr.match(/^>=(\d+)$/))) return (n) => n >= Number(m[1]);
+    if ((m = expr.match(/^>(\d+)$/))) return (n) => n > Number(m[1]);
+    if ((m = expr.match(/^<=(\d+)$/))) return (n) => n <= Number(m[1]);
+    if ((m = expr.match(/^<(\d+)$/))) return (n) => n < Number(m[1]);
+    if ((m = expr.match(/^(\d+)\.\.(\d+)$/))) return (n) => n >= Number(m[1]) && n <= Number(m[2]);
+    if ((m = expr.match(/^(\d+)\.\.\*$/))) return (n) => n >= Number(m[1]);
+    if ((m = expr.match(/^\*\.\.(\d+)$/))) return (n) => n <= Number(m[1]);
+    // buildRangeQualifier already rejected anything else.
+    throw new ArgumentError(`github --watchers value "${value}" is not a valid numeric filter`);
+}
+
+/** Assemble the `q=` search expression from free text plus every dimension. */
+export function buildQuery(args = {}) {
+    const parts = [];
+    const freeText = String(args.query ?? '').trim();
+    if (freeText) parts.push(freeText);
+
+    for (const [flag, field] of [['stars', 'stars'], ['forks', 'forks'], ['issues', 'good-first-issues'], ['size', 'size']]) {
+        if (args[flag] != null && String(args[flag]).trim()) {
+            parts.push(buildRangeQualifier(field, args[flag]));
+        }
+    }
+    for (const [flag, field] of [['pushed', 'pushed'], ['created', 'created']]) {
+        if (args[flag] != null && String(args[flag]).trim()) {
+            parts.push(buildDateQualifier(field, args[flag]));
+        }
+    }
+    for (const [flag, field] of [['language', 'language'], ['topic', 'topic'], ['license', 'license']]) {
+        for (const term of splitTerms(args[flag])) {
+            parts.push(`${field}:${quoteIfNeeded(term)}`);
+        }
+    }
+    for (const term of splitTerms(args.owner)) {
+        parts.push(`user:${term}`);
+    }
+    if (args.in) {
+        const fields = splitTerms(args.in);
+        const allowed = new Set(['name', 'description', 'readme', 'topics']);
+        for (const f of fields) {
+            if (!allowed.has(f)) {
+                throw new ArgumentError(
+                    `github --in value "${f}" is not searchable`,
+                    'GitHub restricts free-text scope to: name, description, readme, topics.',
+                );
+            }
+        }
+        if (fields.length) parts.push(`in:${fields.join(',')}`);
+    }
+    // GitHub excludes forks from search by default; archived repos are included.
+    if (args['include-forks']) parts.push('fork:true');
+    if (!args['include-archived']) parts.push('archived:false');
+
+    // `archived:false` alone is a valid GitHub query but would silently return
+    // "every non-archived repo", which is never what the caller meant.
+    const meaningful = parts.filter((p) => p !== 'archived:false' && p !== 'fork:true');
+    if (!meaningful.length) {
+        throw new ArgumentError(
+            'github search needs a query or at least one filter',
+            'Pass a keyword, or a dimension such as --stars ">10000" --language rust --topic cli.',
+        );
+    }
+    return parts.join(' ');
+}
+
+/** Run `mapper` over `items` with a bounded number of in-flight requests. */
+async function mapWithConcurrency(items, concurrency, mapper) {
+    const out = new Array(items.length);
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+        while (cursor < items.length) {
+            const i = cursor++;
+            out[i] = await mapper(items[i], i);
+        }
+    });
+    await Promise.all(workers);
+    return out;
+}
+
+/**
+ * Fetch the real watch count (`subscribers_count`) for each row.
+ *
+ * One core-API call per repo. Failures degrade to `null` rather than killing
+ * the whole search — a single deleted/renamed repo shouldn't lose 99 good rows.
+ */
+async function enrichWatchers(rows) {
+    return mapWithConcurrency(rows, ENRICH_CONCURRENCY, async (row) => {
+        try {
+            const detail = await githubFetch(
+                `${GITHUB_API}/repos/${row.full_name}`,
+                'github search (watch count)',
+                { allow404: false },
+            );
+            return { ...row, watchers: detail?.subscribers_count != null ? Number(detail.subscribers_count) : null };
+        }
+        catch {
+            return { ...row, watchers: null };
+        }
+    });
+}
+
+/** Shape one raw search item into an output row. */
+function toRow(item) {
+    return {
+        rank: 0, // assigned after filtering/sorting
+        full_name: String(item?.full_name ?? ''),
+        stars: item?.stargazers_count != null ? Number(item.stargazers_count) : null,
+        forks: item?.forks_count != null ? Number(item.forks_count) : null,
+        // Deliberately null: the search payload's `watchers_count` is a copy of
+        // the star count, not a watch count. Only enrichment fills this in.
+        watchers: null,
+        language: String(item?.language ?? ''),
+        description: String(item?.description ?? '').trim(),
+        license: String(item?.license?.spdx_id ?? ''),
+        topics: Array.isArray(item?.topics) ? item.topics.join(', ') : '',
+        open_issues: item?.open_issues_count != null ? Number(item.open_issues_count) : null,
+        pushed: String(item?.pushed_at ?? '').slice(0, 10),
+        url: String(item?.html_url ?? (item?.full_name ? `https://github.com/${item.full_name}` : '')),
+    };
+}
+
+cli({
+    site: 'github',
+    name: 'search',
+    access: 'read',
+    description: 'Search GitHub repositories by stars, forks, watchers, language, topic and more',
+    domain: 'api.github.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: false, help: 'Free-text keyword; optional when at least one filter flag is given' },
+        { name: 'stars', help: 'Star count filter: "5000" (>=), ">10000", "<500", "1000..5000"' },
+        { name: 'forks', help: 'Fork count filter, same syntax as --stars' },
+        { name: 'watchers', help: 'Watch count filter, same syntax as --stars (client-side; costs 1 API call per scanned repo)' },
+        { name: 'language', help: 'Primary language, comma-separated for multiple (e.g. "rust,go")' },
+        { name: 'topic', help: 'Repository topic, comma-separated for multiple (e.g. "cli,devtools")' },
+        { name: 'license', help: 'License keyword (e.g. "mit", "apache-2.0")' },
+        { name: 'size', help: 'Repo size in KB: "1000" (>=), "<500", "100..1000"' },
+        { name: 'pushed', help: 'Last push date: "2026-01-01" (>=), ">2026-01-01", "2025-01-01..2026-01-01"' },
+        { name: 'created', help: 'Creation date, same syntax as --pushed' },
+        { name: 'issues', help: 'Good-first-issue count filter, same syntax as --stars' },
+        { name: 'owner', help: 'Restrict to owners/orgs, comma-separated (e.g. "facebook,vercel")' },
+        { name: 'in', help: 'Restrict free-text match to: name, description, readme, topics (comma-separated)' },
+        { name: 'include-forks', type: 'bool', default: false, help: 'Include forked repos (GitHub excludes them by default)' },
+        { name: 'include-archived', type: 'bool', default: false, help: 'Include archived repos' },
+        {
+            name: 'sort',
+            default: 'best-match',
+            choices: ['best-match', 'stars', 'forks', 'watchers', 'updated', 'help-wanted-issues'],
+            help: 'Ranking dimension; "watchers" sorts client-side and enriches every scanned row',
+        },
+        { name: 'order', default: 'desc', choices: ['desc', 'asc'], help: 'Sort direction' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+        { name: 'page', type: 'int', default: 1, help: 'Result page; GitHub never serves past result 1000' },
+        { name: 'scan', type: 'int', default: 30, help: 'Candidate pool size when filtering/sorting by watchers (1-100, one API call each)' },
+        { name: 'with-watchers', type: 'bool', default: false, help: 'Add the real watch count column without filtering on it' },
+    ],
+    columns: ['rank', 'full_name', 'stars', 'forks', 'watchers', 'language', 'description', 'license', 'topics', 'open_issues', 'pushed', 'url'],
+    func: async (args) => {
+        const limit = requireBoundedInt(args.limit, 20, MAX_LIMIT);
+        const page = requireBoundedInt(args.page, 1, MAX_SEARCH_WINDOW);
+        const sort = String(args.sort ?? 'best-match');
+        const order = String(args.order ?? 'desc') === 'asc' ? 'asc' : 'desc';
+        const wantsWatchers = Boolean(args.watchers) || Boolean(args['with-watchers']) || sort === 'watchers';
+        const q = buildQuery(args);
+
+        // Watch-count work happens client-side, so pull a larger candidate pool
+        // to filter/sort down from. Everything else is filtered by GitHub.
+        const scan = wantsWatchers ? requireBoundedInt(args.scan, 30, MAX_SCAN, 'scan') : limit;
+        const perPage = wantsWatchers ? Math.max(scan, limit) : limit;
+
+        if (page * perPage > MAX_SEARCH_WINDOW) {
+            throw new ArgumentError(
+                `github search cannot reach page ${page} at ${perPage} results per page`,
+                `GitHub's search index stops at result ${MAX_SEARCH_WINDOW}; narrow the query with more filters instead.`,
+            );
+        }
+
+        const url = new URL(`${GITHUB_API}/search/repositories`);
+        url.searchParams.set('q', q);
+        url.searchParams.set('per_page', String(Math.min(perPage, MAX_LIMIT)));
+        url.searchParams.set('page', String(page));
+        // `best-match` is GitHub's default and is expressed by omitting `sort`.
+        if (SERVER_SORTS.has(sort)) {
+            url.searchParams.set('sort', sort);
+            url.searchParams.set('order', order);
+        }
+        else if (sort === 'watchers') {
+            // No server-side watch sort exists; rank the pool by stars so the
+            // scanned candidates are the plausible ones, then re-sort locally.
+            url.searchParams.set('sort', 'stars');
+            url.searchParams.set('order', 'desc');
+        }
+
+        const body = await githubFetch(url.toString(), 'github search');
+        const items = Array.isArray(body?.items) ? body.items : [];
+        if (!items.length) {
+            throw new EmptyResultError('github search', `No GitHub repositories matched "${q}".`);
+        }
+
+        let rows = items.map(toRow).filter((r) => r.full_name);
+        if (wantsWatchers) {
+            rows = await enrichWatchers(rows.slice(0, scan));
+            if (args.watchers != null && String(args.watchers).trim()) {
+                const pred = compileWatchersPredicate(args.watchers);
+                rows = rows.filter((r) => r.watchers != null && pred(r.watchers));
+            }
+            if (sort === 'watchers') {
+                rows.sort((a, b) => (order === 'asc'
+                    ? (a.watchers ?? Infinity) - (b.watchers ?? Infinity)
+                    : (b.watchers ?? -1) - (a.watchers ?? -1)));
+            }
+        }
+
+        rows = rows.slice(0, limit);
+        if (!rows.length) {
+            throw new EmptyResultError(
+                'github search',
+                `No repositories in the top ${scan} results for "${q}" matched --watchers ${args.watchers}. Raise --scan or loosen the filter.`,
+            );
+        }
+        return rows.map((r, i) => ({ ...r, rank: i + 1 }));
+    },
+});

package/clis/github/utils.js

@@ -0,0 +1,150 @@
+// Shared helpers for the GitHub adapters that hit the public REST API
+// (api.github.com). No browser, no cookies — `GITHUB_TOKEN` is optional and
+// only raises the rate limit (60/hr → 5000/hr core, 10/min → 30/min search).
+import { ArgumentError, CommandExecutionError, EmptyResultError, RateLimitedError } from '@sovovs/bycli/errors';
+
+export const GITHUB_API = 'https://api.github.com';
+const UA = 'bycli-github-adapter (+https://github.com/sovovs/byCLI)';
+
+// owner/repo full names: owner is 1-39 chars of alnum/hyphen, repo adds ._-
+const FULL_NAME = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9_.-]{1,100}$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`github ${label} cannot be empty`);
+    return s;
+}
+
+export function requireFullName(value) {
+    const s = String(value ?? '').trim().replace(/^https?:\/\/(?:www\.)?github\.com\//i, '').replace(/\.git$/i, '').replace(/\/+$/, '');
+    if (!s) throw new ArgumentError('github repo is required (e.g. "facebook/react")');
+    if (!FULL_NAME.test(s)) {
+        throw new ArgumentError(
+            `github repo "${value}" is not a valid "owner/repo" name`,
+            'Pass the full name from a search row, e.g. "facebook/react" (or its github.com URL).',
+        );
+    }
+    return s;
+}
+
+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(`github ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`github ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+function authHeaders() {
+    const token = String(process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? '').trim();
+    return token ? { authorization: `Bearer ${token}` } : {};
+}
+
+/**
+ * Build a `>N` / `<N` / `>=N` / `A..B` numeric range qualifier from a raw arg.
+ *
+ * GitHub accepts `stars:>100`, `stars:>=100`, `stars:<50`, `stars:10..50` and
+ * `stars:100..*`. A bare number is treated as `>=N`, which is what people mean
+ * by "at least 1000 stars" — exact-match `stars:1000` is almost never wanted.
+ */
+export function buildRangeQualifier(field, value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) return '';
+    const compact = raw.replace(/\s+/g, '');
+    if (/^\d+$/.test(compact)) return `${field}:>=${compact}`;
+    if (/^(?:>=|<=|>|<)\d+$/.test(compact)) return `${field}:${compact}`;
+    if (/^\d+\.\.(?:\d+|\*)$/.test(compact)) return `${field}:${compact}`;
+    if (/^\*\.\.\d+$/.test(compact)) return `${field}:${compact}`;
+    throw new ArgumentError(
+        `github --${field} value "${raw}" is not a valid numeric filter`,
+        'Use a bare number (>=N), a comparison (">100", ">=100", "<50"), or a range ("10..50", "100..*").',
+    );
+}
+
+/** Same idea for date fields (`pushed`, `created`): ISO date or comparison/range. */
+export function buildDateQualifier(field, value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) return '';
+    const compact = raw.replace(/\s+/g, '');
+    const D = '\\d{4}-\\d{2}-\\d{2}';
+    if (new RegExp(`^${D}$`).test(compact)) return `${field}:>=${compact}`;
+    if (new RegExp(`^(?:>=|<=|>|<)${D}$`).test(compact)) return `${field}:${compact}`;
+    if (new RegExp(`^${D}\\.\\.(?:${D}|\\*)$`).test(compact)) return `${field}:${compact}`;
+    if (new RegExp(`^\\*\\.\\.${D}$`).test(compact)) return `${field}:${compact}`;
+    throw new ArgumentError(
+        `github --${field} value "${raw}" is not a valid date filter`,
+        'Use YYYY-MM-DD (>=date), a comparison (">2026-01-01"), or a range ("2025-01-01..2026-01-01").',
+    );
+}
+
+export async function githubFetch(url, label, { allow404 = true } = {}) {
+    let resp;
+    try {
+        resp = await fetch(url, {
+            headers: {
+                'user-agent': UA,
+                accept: 'application/vnd.github+json',
+                'x-github-api-version': '2022-11-28',
+                ...authHeaders(),
+            },
+            redirect: 'follow',
+        });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.github.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404 && allow404) {
+        throw new EmptyResultError(label, `GitHub API returned 404 for ${url}.`);
+    }
+    // GitHub signals both rate limiting and abuse detection with 403/429.
+    if (resp.status === 403 || resp.status === 429) {
+        const remaining = resp.headers.get('x-ratelimit-remaining');
+        const reset = Number(resp.headers.get('x-ratelimit-reset'));
+        const waitHint = Number.isFinite(reset) && reset > 0
+            ? ` Limit resets at ${new Date(reset * 1000).toISOString()}.`
+            : '';
+        if (remaining === '0' || resp.status === 429) {
+            throw new RateLimitedError(
+                `${label} hit the GitHub API rate limit (HTTP ${resp.status})`,
+                `Unauthenticated search allows 10 req/min.${waitHint} Set GITHUB_TOKEN to raise it to 30 req/min.`,
+            );
+        }
+        throw new CommandExecutionError(
+            `${label} was refused by GitHub (HTTP 403)`,
+            'The API may require authentication for this resource; set GITHUB_TOKEN.',
+        );
+    }
+    if (resp.status === 422) {
+        let detail = '';
+        try {
+            const body = await resp.json();
+            const fields = Array.isArray(body?.errors)
+                ? body.errors.map((e) => e?.field ?? e?.message).filter(Boolean).join(', ')
+                : '';
+            detail = fields ? ` (${fields})` : (body?.message ? ` (${body.message})` : '');
+        }
+        catch { /* body already unreadable; fall through with no detail */ }
+        throw new ArgumentError(
+            `${label} was rejected by GitHub as an invalid query${detail}`,
+            'Check the qualifier syntax; GitHub rejects malformed values like "stars:abc".',
+        );
+    }
+    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;
+}

package/clis/juejin/search.js

@@ -0,0 +1,372 @@
+// juejin search — 掘金站内搜索，覆盖页面上的三个筛选维度。
+//
+// 单一 endpoint `GET api.juejin.cn/search_api/v1/search` 同时驱动网页上的
+// 三组筛选控件，参数名和 UI 标签对应关系（从 juejin web bundle 的枚举表读出，
+// 见 xitu_juejin_web/fa804e1.js 的 `{left: [...], right: [...]}`）：
+//
+//   id_type     → 顶部一级 tab：综合(0) / 文章(2) / 课程(12) / 标签(9) / 用户(1)
+//   sort_type   → 排序 tab：综合排序(0) / 最新优先(1) / 最热优先(2)
+//   search_type → 时间范围下拉：时间不限(0) / 最近一天(1) / 最近一周(2) / 最近三月(3)
+//
+// `search_type` 的命名容易误读成"搜索类型"，实际是时间窗（bundle 里这个参数由
+// 名为 `period` 的变量传入），所以 CLI 侧暴露成 `--period` 而不是照搬 API 名。
+//
+// 响应是异构列表：每个 entry 带 `result_type` 决定 `result_model` 的形状
+// （2=文章 / 1=用户 / 9=标签 / 12=课程小册）。综合 tab 会混排多种类型，
+// 所以行结构做成一张统一表：identity 列 + 通用指标列，各类型特有的次要字段
+// 折进 `extra`，避免列数爆炸又不丢信息。
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+
+const API = 'https://api.juejin.cn/search_api/v1/search';
+
+// 每页固定 20 条：limit 参数被服务端忽略（传 5 或 50 都返回 20），
+// 分页只认 cursor，所以自己按 cursor 翻页再截断到用户要的条数。
+const PAGE_SIZE = 20;
+const MAX_LIMIT = 200;
+const MAX_PAGES = 30;
+
+const TYPES = {
+    all: 0,
+    article: 2,
+    course: 12,
+    tag: 9,
+    user: 1,
+};
+
+const SORTS = {
+    relevance: 0,
+    newest: 1,
+    hottest: 2,
+};
+
+const PERIODS = {
+    all: 0,
+    day: 1,
+    week: 2,
+    month3: 3,
+};
+
+const RESULT_TYPES = {
+    1: 'user',
+    2: 'article',
+    9: 'tag',
+    12: 'course',
+};
+
+function requireQuery(value) {
+    const query = String(value ?? '').trim();
+    if (!query) {
+        throw new ArgumentError('juejin search query must not be empty', 'Example: bycli juejin search golang --sort hottest');
+    }
+    return query;
+}
+
+function requireChoice(value, table, flag, example) {
+    const key = String(value ?? '');
+    if (!Object.prototype.hasOwnProperty.call(table, key)) {
+        throw new ArgumentError(`juejin search --${flag} must be one of: ${Object.keys(table).join(', ')}`, example);
+    }
+    return table[key];
+}
+
+function requireLimit(value) {
+    const raw = value ?? 20;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError('juejin search --limit must be a positive integer');
+    }
+    if (n > MAX_LIMIT) {
+        throw new ArgumentError(`juejin search --limit must be <= ${MAX_LIMIT}`, 'Deep pagination hits juejin rate limits; narrow the query instead');
+    }
+    return n;
+}
+
+function toIsoTime(seconds) {
+    const n = Number(seconds);
+    // 掘金对"没有时间"用 -62135596800（Go 零值 time.Time）而不是 0/null。
+    if (!Number.isFinite(n) || n <= 0) return null;
+    return new Date(n * 1000).toISOString();
+}
+
+// rtime(发布时间) 在**较新**的文章上是 Go 零值 -62135596800，只有老文章才填。
+// 所以不能写 `rtime ?? ctime`（?? 只兜 null/undefined，兜不住这个哨兵值），
+// 必须按"第一个能转出合法时间的字段"取，否则 --sort newest 整列时间全 null。
+function firstIsoTime(...candidates) {
+    for (const candidate of candidates) {
+        const iso = toIsoTime(candidate);
+        if (iso) return iso;
+    }
+    return null;
+}
+
+function textOf(value) {
+    return String(value ?? '').trim();
+}
+
+function buildUrl({ query, idType, sortType, period, cursor }) {
+    const url = new URL(API);
+    url.searchParams.set('aid', '2608');
+    url.searchParams.set('spider', '0');
+    url.searchParams.set('version', '1');
+    url.searchParams.set('query', query);
+    url.searchParams.set('id_type', String(idType));
+    url.searchParams.set('sort_type', String(sortType));
+    url.searchParams.set('search_type', String(period));
+    url.searchParams.set('cursor', cursor);
+    url.searchParams.set('limit', String(PAGE_SIZE));
+    return url.toString();
+}
+
+async function fetchPage(url) {
+    let resp;
+    try {
+        resp = await fetch(url, {
+            headers: {
+                accept: 'application/json',
+                'user-agent': 'Mozilla/5.0',
+                referer: 'https://juejin.cn/',
+            },
+        });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `juejin search request failed: ${err?.message ?? err}`,
+            'Check that api.juejin.cn is reachable from this network.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`juejin search returned HTTP ${resp.status}`, `URL: ${url}`);
+    }
+    let payload;
+    try {
+        payload = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`juejin search returned malformed JSON: ${err?.message ?? err}`);
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new CommandExecutionError('juejin search returned malformed payload');
+    }
+    if (payload.err_no !== 0) {
+        throw new CommandExecutionError(`juejin search API error: ${textOf(payload.err_msg) || `err_no ${payload.err_no}`}`);
+    }
+    if (!Array.isArray(payload.data)) {
+        throw new CommandExecutionError('juejin search returned malformed data list', `URL: ${url}`);
+    }
+    return payload;
+}
+
+// 每个分支返回中间结构（identity/label/…），最后统一映射到 columns 命名，
+// 避免中间 key 和 columns 重叠触发 silent-column-drop 误判。
+function normalizeArticle(model) {
+    const info = model?.article_info;
+    if (!info || typeof info !== 'object') return null;
+    const identity = textOf(model.article_id ?? info.article_id);
+    const label = textOf(info.title);
+    if (!identity || !label) return null;
+    return {
+        identity,
+        label,
+        byline: textOf(model.author_user_info?.user_name),
+        viewTotal: Number(info.view_count ?? 0),
+        likeTotal: Number(info.digg_count ?? 0),
+        commentTotal: Number(info.comment_count ?? 0),
+        heat: Number(info.hot_index ?? 0),
+        stamp: firstIsoTime(info.rtime, info.ctime),
+        link: `https://juejin.cn/post/${identity}`,
+        aside: {
+            collect_count: Number(info.collect_count ?? 0),
+            category: textOf(model.category?.category_name) || null,
+            // 逗号连接而不是数组：row shape 门禁要求嵌套深度 <= 1（agent-native 行）。
+            tags: (Array.isArray(model.tags) ? model.tags : [])
+                .map((tag) => textOf(tag?.tag_name))
+                .filter(Boolean)
+                .join(',') || null,
+            brief: textOf(info.brief_content) || null,
+            is_original: info.is_original === 1,
+        },
+    };
+}
+
+function normalizeUser(model) {
+    const identity = textOf(model?.user_id);
+    const label = textOf(model?.user_name);
+    if (!identity || !label) return null;
+    return {
+        identity,
+        label,
+        // 用户自身就是作者，byline 放职位/公司当副标题更有信息量。
+        byline: [textOf(model.job_title), textOf(model.company)].filter(Boolean).join(' @ '),
+        viewTotal: Number(model.got_view_count ?? 0),
+        likeTotal: Number(model.got_digg_count ?? 0),
+        commentTotal: null,
+        heat: Number(model.follower_count ?? 0),
+        stamp: null,
+        link: `https://juejin.cn/user/${identity}`,
+        aside: {
+            level: Number(model.level ?? 0),
+            follower_count: Number(model.follower_count ?? 0),
+            post_article_count: Number(model.post_article_count ?? 0),
+            description: textOf(model.description) || null,
+        },
+    };
+}
+
+function normalizeTag(model) {
+    const tag = model?.tag;
+    const identity = textOf(model?.tag_id ?? tag?.tag_id);
+    const label = textOf(tag?.tag_name);
+    if (!identity || !label) return null;
+    return {
+        identity,
+        label,
+        byline: null,
+        viewTotal: null,
+        likeTotal: null,
+        commentTotal: null,
+        heat: Number(tag?.concern_user_count ?? 0),
+        stamp: toIsoTime(tag?.ctime),
+        link: `https://juejin.cn/tag/${encodeURIComponent(label)}`,
+        aside: {
+            post_article_count: Number(tag?.post_article_count ?? 0),
+            concern_user_count: Number(tag?.concern_user_count ?? 0),
+        },
+    };
+}
+
+function normalizeCourse(model) {
+    const base = model?.base_info;
+    const identity = textOf(model?.booklet_id ?? base?.booklet_id);
+    const label = textOf(base?.title);
+    if (!identity || !label) return null;
+    return {
+        identity,
+        label,
+        byline: textOf(model.user_info?.user_name),
+        viewTotal: Number(base?.read_time ?? 0),
+        likeTotal: null,
+        commentTotal: null,
+        heat: Number(base?.buy_count ?? 0),
+        stamp: firstIsoTime(base?.put_on_time, base?.ctime),
+        link: `https://juejin.cn/book/${identity}`,
+        aside: {
+            // price 是分，转成元避免下游误读成 2990 元。
+            price_yuan: Number.isFinite(Number(base?.price)) ? Number(base.price) / 100 : null,
+            section_count: Number(base?.section_count ?? 0),
+            buy_count: Number(base?.buy_count ?? 0),
+            summary: textOf(base?.summary) || null,
+        },
+    };
+}
+
+const NORMALIZERS = {
+    article: normalizeArticle,
+    user: normalizeUser,
+    tag: normalizeTag,
+    course: normalizeCourse,
+};
+
+function normalizeEntry(entry) {
+    if (!entry || typeof entry !== 'object') return null;
+    const kind = RESULT_TYPES[entry.result_type];
+    // 掘金以后可能加新的 result_type（沸点等）。未知类型静默跳过而不是抛错，
+    // 否则综合 tab 上线一个新卡片类型就会让整个命令挂掉。
+    if (!kind) return null;
+    const parsed = NORMALIZERS[kind](entry.result_model);
+    if (!parsed) return null;
+    return { resultKind: kind, parsed };
+}
+
+cli({
+    site: 'juejin',
+    name: 'search',
+    access: 'read',
+    description: '掘金搜索，支持综合/文章/课程/标签/用户维度与综合/最新/最热排序',
+    domain: 'api.juejin.cn',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', required: true, positional: true, help: '搜索关键词' },
+        { name: 'type', default: 'all', choices: Object.keys(TYPES), help: '结果类型：all(综合) / article(文章) / course(课程) / tag(标签) / user(用户)' },
+        { name: 'sort', default: 'relevance', choices: Object.keys(SORTS), help: '排序：relevance(综合) / newest(最新优先) / hottest(最热优先)' },
+        { name: 'period', default: 'all', choices: Object.keys(PERIODS), help: '时间范围：all(不限) / day(最近一天) / week(最近一周) / month3(最近三月)' },
+        { name: 'limit', type: 'int', default: 20, help: `返回条数 (max ${MAX_LIMIT})` },
+    ],
+    columns: ['rank', 'kind', 'id', 'title', 'author', 'views', 'likes', 'comments', 'hot_index', 'published_at', 'url', 'extra'],
+    func: async (args) => {
+        const query = requireQuery(args.query);
+        const idType = requireChoice(args.type, TYPES, 'type', 'Example: bycli juejin search rust --type article');
+        const sortType = requireChoice(args.sort, SORTS, 'sort', 'Example: bycli juejin search rust --sort hottest');
+        const period = requireChoice(args.period, PERIODS, 'period', 'Example: bycli juejin search rust --period week');
+        const limit = requireLimit(args.limit);
+
+        const rows = [];
+        const seen = new Set();
+        let cursor = '0';
+        let pages = 0;
+
+        while (rows.length < limit && pages < MAX_PAGES) {
+            const url = buildUrl({ query, idType, sortType, period, cursor });
+            const payload = await fetchPage(url);
+            pages += 1;
+
+            for (const entry of payload.data) {
+                const normalized = normalizeEntry(entry);
+                if (!normalized) continue;
+                const { resultKind: kind, parsed } = normalized;
+                const dedupeKey = `${kind}:${parsed.identity}`;
+                // 服务端跨页会重复少量结果（实测 6 页 118 条里 6 条重复）。
+                if (seen.has(dedupeKey)) continue;
+                seen.add(dedupeKey);
+                rows.push({
+                    rank: rows.length + 1,
+                    kind,
+                    id: parsed.identity,
+                    title: parsed.label,
+                    author: parsed.byline || null,
+                    views: parsed.viewTotal,
+                    likes: parsed.likeTotal,
+                    comments: parsed.commentTotal,
+                    hot_index: parsed.heat,
+                    published_at: parsed.stamp,
+                    url: parsed.link,
+                    extra: parsed.aside,
+                });
+                if (rows.length >= limit) break;
+            }
+
+            if (rows.length >= limit) break;
+            const nextCursor = textOf(payload.cursor);
+            if (!payload.has_more || !nextCursor || nextCursor === cursor) break;
+            cursor = nextCursor;
+        }
+
+        if (rows.length === 0) {
+            throw new EmptyResultError('juejin search', `No ${args.type === 'all' ? '' : `${args.type} `}results for "${query}"`);
+        }
+        return rows;
+    },
+});
+
+export const __test__ = {
+    TYPES,
+    SORTS,
+    PERIODS,
+    RESULT_TYPES,
+    PAGE_SIZE,
+    MAX_LIMIT,
+    MAX_PAGES,
+    requireQuery,
+    requireChoice,
+    requireLimit,
+    toIsoTime,
+    firstIsoTime,
+    buildUrl,
+    fetchPage,
+    normalizeArticle,
+    normalizeUser,
+    normalizeTag,
+    normalizeCourse,
+    normalizeEntry,
+};

package/clis/weixin/create-draft.js

@@ -62,7 +62,7 @@ async function getToken(page) {
 }
 
 async function navigateToEditor(page) {
-    await page.goto(WEIXIN_HOME);
+    await page.goto(WEIXIN_HOME, { stealth: false });
     await page.wait(3);
     const token = await getToken(page);
     if (!token) {
@@ -71,8 +71,8 @@ async function navigateToEditor(page) {
             'Could not extract session token. Please log in to mp.weixin.qq.com',
         );
     }
-    await page.goto(`https://mp.weixin.qq.com/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=77&token=${token}&lang=zh_CN`);
-    await page.wait(4);
+    await page.goto(`https://mp.weixin.qq.com/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=77&token=${token}&lang=zh_CN`, { stealth: false });
+    await page.wait(10);
     const hasTitle = await page.evaluate('!!document.querySelector("textarea#title")');
     if (!hasTitle) {
         throw new AuthRequiredError(
@@ -101,6 +101,30 @@ async function fillField(page, selector, value) {
     })()`);
 }
 
+// WeChat's editor-integrity check can raise a "浏览器插件存在安全隐患" modal. It is a
+// blocking overlay, so any later click (cover picker, save) would land on its mask.
+// Dismiss it via its own 我知道了 button rather than removing the node, so the
+// editor's own teardown runs.
+async function dismissPluginWarning(page) {
+    return page.evaluate(`(() => {
+        var closed = 0;
+        document.querySelectorAll('.weui-desktop-dialog__wrp, .weui-desktop-dialog').forEach(function(dialog) {
+            if ((dialog.innerText || '').indexOf('\\u5b89\\u5168\\u9690\\u60a3') < 0) return;
+            var wrap = dialog.closest('.weui-desktop-dialog__wrp') || dialog;
+            if (window.getComputedStyle(wrap).display === 'none' || wrap.offsetHeight <= 0) return;
+            var buttons = wrap.querySelectorAll('button, a, .weui-desktop-btn');
+            for (var i = 0; i < buttons.length; i++) {
+                if ((buttons[i].textContent || '').trim() === '\\u6211\\u77e5\\u9053\\u4e86') {
+                    buttons[i].click();
+                    closed++;
+                    return;
+                }
+            }
+        });
+        return { closed: closed };
+    })()`);
+}
+
 async function fillContent(page, text) {
     var result = await page.evaluate(`(() => {
         var normalize = value => String(value ?? '').replace(/\\r\\n?/g, '\\n').trim();
@@ -116,33 +140,51 @@ async function fillContent(page, text) {
                 return { ok: true, value: ueditorActual };
             }
         }
+        // The editor is a rich-text framework (ProseMirror) that owns its DOM, so
+        // only tag it here. Do NOT clear innerHTML, build a Range, or send a
+        // select-all chord: WeChat's editor-integrity check reads those as plugin
+        // tampering and shows a blocking "当前使用的浏览器插件存在安全隐患" modal.
+        // Once that mask is up every click lands on it and no text is ever typed.
+        // page.typeText() drives the editor through CDP DOM.focus + Input.insertText,
+        // which the editor accepts as genuine input.
         var editors = document.querySelectorAll('div[contenteditable="true"]');
         var editor = editors[editors.length - 1];
         if (!editor) return { ok: false, reason: 'content editor not found' };
-        editor.focus();
-        if (editor.querySelector('[contenteditable="false"]')) editor.innerHTML = '';
-        var selection = window.getSelection();
-        if (!selection) return { ok: false, reason: 'text selection is unavailable' };
-        var range = document.createRange();
-        range.selectNodeContents(editor);
-        selection.removeAllRanges();
-        selection.addRange(range);
+        document.querySelectorAll('[data-bycli-content-target]').forEach(element => {
+            element.removeAttribute('data-bycli-content-target');
+        });
+        editor.setAttribute('data-bycli-content-target', 'true');
         return { ok: false, nativeTargetFocused: true };
     })()`);
 
-    if (!result?.nativeTargetFocused || typeof page.nativeType !== 'function') return result;
+    if (!result?.nativeTargetFocused) return result;
+
+    const editorTarget = 'div[contenteditable="true"][data-bycli-content-target="true"]';
+    if (typeof page.focusWindow === 'function') {
+        try { await page.focusWindow(); } catch { /* focus is best-effort */ }
+    }
 
+    if (typeof page.typeText !== 'function') {
+        return { ok: false, reason: 'page.typeText is unavailable for content entry' };
+    }
     try {
-        await page.nativeType(text);
-    } catch {
-        return result;
+        await page.typeText(editorTarget, text);
+    } catch (err) {
+        return { ok: false, reason: `content typing failed: ${String(err).slice(0, 120)}` };
     }
+    await page.wait(1);
+    await dismissPluginWarning(page);
 
     return page.evaluate(`(() => {
-        var normalize = value => String(value ?? '').replace(/\\r\\n?/g, '\\n').trim();
+        // The editor renders paragraph breaks as its own block structure, so its
+        // innerText carries extra blank lines the source text does not have.
+        // Compare on collapsed whitespace instead of exact line breaks.
+        var normalize = value => String(value ?? '')
+            .replace(/\\r\\n?/g, '\\n')
+            .replace(/[\\s\\u00a0\\u200b]+/g, ' ')
+            .trim();
         var expected = normalize(${JSON.stringify(text)});
-        var editors = document.querySelectorAll('div[contenteditable="true"]');
-        var editor = editors[editors.length - 1];
+        var editor = document.querySelector('${editorTarget}');
         if (!editor) return { ok: false, reason: 'content editor not found' };
         var actual = normalize(editor.innerText ?? editor.textContent ?? '');
         return actual === expected
@@ -307,6 +349,7 @@ export const createDraftCommand = cli({
         const args = normalizeCreateDraftArgs(kwargs);
         await navigateToEditor(page);
 
+
         const titleResult = await fillField(page, 'textarea#title', args.title);
         requirePageResult(titleResult, 'title');
 
@@ -315,6 +358,8 @@ export const createDraftCommand = cli({
             requirePageResult(authorResult, 'author');
         }
 
+        await page.wait(10);
+
         const contentResult = await fillContent(page, args.content);
         requirePageResult(contentResult, 'content');
 

package/dist/src/browser/page.d.ts

@@ -32,6 +32,7 @@ export declare class Page extends BasePage {
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
+        stealth?: boolean;
     }): Promise<void>;
     /** Get the active page identity (targetId) */
     getActivePage(): string | undefined;

package/dist/src/browser/page.js

@@ -106,10 +106,13 @@ export class Page extends BasePage {
         }
         this._lastUrl = url;
         // Inject stealth + settle in a single round-trip instead of two sequential exec calls.
-        // The stealth guard flag prevents double-injection; settle uses DOM stability detection.
+        // Some security-sensitive editors reject runtime environment patches, so callers can
+        // retain the normal DOM-settle behavior while opting out of stealth injection.
+        const useStealth = options?.stealth !== false;
         if (options?.waitUntil !== 'none') {
             const maxMs = options?.settleMs ?? 1000;
-            const combinedCode = `${generateStealthJs()};\n${waitForDomStableJs(maxMs, Math.min(500, maxMs))}`;
+            const settleCode = waitForDomStableJs(maxMs, Math.min(500, maxMs));
+            const combinedCode = useStealth ? `${generateStealthJs()};\n${settleCode}` : settleCode;
             const combinedOpts = {
                 code: combinedCode,
                 ...this._cmdOpts(),
@@ -134,7 +137,7 @@ export class Page extends BasePage {
                 }
             }
         }
-        else {
+        else if (useStealth) {
             // Even with waitUntil='none', still inject stealth (best-effort)
             try {
                 await sendCommand('exec', {

package/dist/src/types.d.ts

@@ -70,6 +70,7 @@ export interface IPage {
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
+        stealth?: boolean;
     }): Promise<void>;
     evaluate<T = any>(js: string): Promise<T>;
     evaluate<Args extends unknown[], T>(fn: BrowserEvaluateFunction<Args, T>, ...args: Args): Promise<Awaited<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.28",
+  "version": "2.1.29",
   "publishConfig": {
     "access": "public"
   },