@jackwener/opencli 1.7.11 → 1.7.13

package/clis/nuget/utils.js

@@ -0,0 +1,87 @@
+// Shared helpers for the NuGet adapters.
+//
+// NuGet exposes two complementary endpoints:
+//   • `azuresearch-usnc.nuget.org/query` — full-text package search (V3)
+//   • `api.nuget.org/v3/registration5-semver1/<id>/index.json` — package detail
+// No API key required. Anonymous traffic is generous; we set a polite UA.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const NUGET_SEARCH_BASE = 'https://azuresearch-usnc.nuget.org';
+export const NUGET_REGISTRATION_BASE = 'https://api.nuget.org/v3/registration5-semver1';
+const UA = 'opencli-nuget-adapter/1.0 (+https://github.com/jackwener/opencli; mailto:opencli@example.com)';
+
+// NuGet ID grammar (NuGet docs §package-id): up to 100 chars, alnum + `.` + `_` + `-`,
+// must start with letter/digit. Case-insensitive; we lowercase for the registration URL
+// because NuGet's CDN is case-sensitive on the path.
+const PACKAGE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,99})$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`nuget ${label} cannot be empty`);
+    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(`nuget ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`nuget ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requirePackageId(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) throw new ArgumentError('nuget package id is required (e.g. "Newtonsoft.Json")');
+    if (!PACKAGE_ID_PATTERN.test(raw)) {
+        throw new ArgumentError(
+            `nuget package id "${value}" is not a valid NuGet identifier`,
+            'NuGet IDs are 1-100 chars: letters/digits/`.`/`_`/`-`, starting with letter or digit.',
+        );
+    }
+    return raw;
+}
+
+export async function nugetFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.nuget.org is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `NuGet returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(`${label} returned HTTP 429 (rate limited)`);
+    }
+    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;
+}
+
+export function joinTags(tags) {
+    if (!Array.isArray(tags)) return '';
+    return tags.filter((t) => typeof t === 'string' && t.trim()).join(', ');
+}
+
+export function joinAuthors(authors) {
+    if (Array.isArray(authors)) return authors.filter((a) => typeof a === 'string' && a.trim()).join(', ');
+    if (typeof authors === 'string') return authors.trim();
+    return '';
+}

package/clis/nvd/cve.js

@@ -0,0 +1,121 @@
+// nvd cve — fetch a single CVE from the NIST National Vulnerability Database.
+//
+// Hits the CVE API 2.0 (`services.nvd.nist.gov/rest/json/cves/2.0?cveId=…`).
+// Returns the agent-useful projection: id, published / last-modified dates,
+// vuln status, English description, CVSS v3.1 base score / severity / vector,
+// CWE id(s), CISA KEV flag.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const NVD_BASE = 'https://services.nvd.nist.gov/rest/json/cves/2.0';
+const UA = 'opencli-nvd-adapter (+https://github.com/jackwener/opencli)';
+const CVE_ID = /^CVE-\d{4}-\d{4,}$/i;
+
+function requireCveId(value) {
+    const s = String(value ?? '').trim().toUpperCase();
+    if (!s) throw new ArgumentError('nvd CVE id is required (e.g. "CVE-2021-44228")');
+    if (!CVE_ID.test(s)) {
+        throw new ArgumentError(
+            `nvd CVE id "${value}" is not a valid CVE identifier`,
+            'Expected the form "CVE-YYYY-N..." with at least 4 sequence digits.',
+        );
+    }
+    return s;
+}
+
+function pickEnglishDescription(descriptions) {
+    if (!Array.isArray(descriptions)) return '';
+    const en = descriptions.find((d) => d?.lang === 'en');
+    return String(en?.value ?? descriptions[0]?.value ?? '').trim();
+}
+
+function pickPrimaryCvss(metrics) {
+    if (!metrics || typeof metrics !== 'object') return null;
+    const candidates = [
+        ...(Array.isArray(metrics.cvssMetricV31) ? metrics.cvssMetricV31 : []),
+        ...(Array.isArray(metrics.cvssMetricV30) ? metrics.cvssMetricV30 : []),
+        ...(Array.isArray(metrics.cvssMetricV2) ? metrics.cvssMetricV2 : []),
+    ];
+    return candidates.find((m) => m?.type === 'Primary') || candidates[0] || null;
+}
+
+function joinCwes(weaknesses) {
+    if (!Array.isArray(weaknesses)) return '';
+    const ids = new Set();
+    for (const w of weaknesses) {
+        for (const desc of w?.description ?? []) {
+            if (desc?.value) ids.add(String(desc.value));
+        }
+    }
+    return [...ids].join(', ');
+}
+
+cli({
+    site: 'nvd',
+    name: 'cve',
+    access: 'read',
+    description: 'NIST NVD CVE detail (description, CVSS, CWE, KEV flag)',
+    domain: 'services.nvd.nist.gov',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'CVE identifier (e.g. "CVE-2021-44228")' },
+    ],
+    columns: [
+        'id', 'published', 'lastModified', 'vulnStatus', 'baseScore', 'severity',
+        'attackVector', 'cwe', 'kevAdded', 'description', 'url',
+    ],
+    func: async (args) => {
+        const id = requireCveId(args.id);
+        const url = `${NVD_BASE}?cveId=${encodeURIComponent(id)}`;
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+        }
+        catch (err) {
+            throw new CommandExecutionError(`nvd cve request failed: ${err?.message ?? err}`);
+        }
+        if (resp.status === 403) {
+            throw new CommandExecutionError(
+                'nvd cve returned HTTP 403',
+                'NVD enforces aggressive rate limits without an API key. Wait, then retry or set NVD_API_KEY (not yet wired).',
+            );
+        }
+        if (resp.status === 429) {
+            throw new CommandExecutionError(
+                'nvd cve returned HTTP 429 (rate limited)',
+                'NVD throttles unauthenticated traffic; wait several seconds before retry.',
+            );
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`nvd cve returned HTTP ${resp.status}`);
+        }
+        let body;
+        try {
+            body = await resp.json();
+        }
+        catch (err) {
+            throw new CommandExecutionError(`nvd cve returned malformed JSON: ${err?.message ?? err}`);
+        }
+        const list = Array.isArray(body?.vulnerabilities) ? body.vulnerabilities : [];
+        const cve = list[0]?.cve;
+        if (!cve || !cve.id) {
+            throw new EmptyResultError('nvd cve', `NVD has no record for "${id}".`);
+        }
+        const cvss = pickPrimaryCvss(cve.metrics);
+        const cvssData = cvss?.cvssData ?? {};
+        return [{
+            id: String(cve.id),
+            published: String(cve.published ?? '').slice(0, 10),
+            lastModified: String(cve.lastModified ?? '').slice(0, 10),
+            vulnStatus: String(cve.vulnStatus ?? ''),
+            baseScore: cvssData.baseScore != null ? Number(cvssData.baseScore) : null,
+            severity: String(cvssData.baseSeverity ?? cvss?.baseSeverity ?? ''),
+            attackVector: String(cvssData.attackVector ?? ''),
+            cwe: joinCwes(cve.weaknesses),
+            kevAdded: cve.cisaExploitAdd ? String(cve.cisaExploitAdd).slice(0, 10) : '',
+            description: pickEnglishDescription(cve.descriptions),
+            url: `https://nvd.nist.gov/vuln/detail/${cve.id}`,
+        }];
+    },
+});

package/clis/oeis/oeis.test.js

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './sequence.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('oeis search adapter', () => {
+    const cmd = getRegistry().get('oeis/search');
+
+    it('rejects bad args before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(cmd.func({ query: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 999 })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        // Fresh Response per call so we don't tickle "Body has already been read" between pages.
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(() => Promise.resolve(new Response('throttled', { status: 429 }))));
+        await expect(cmd.func({ query: 'fibonacci', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when first page is empty', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(() => Promise.resolve(new Response(JSON.stringify([]), { status: 200 }))));
+        await expect(cmd.func({ query: 'no-results', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('round-trips A-id from search row into oeis.org URL', async () => {
+        const result = [{
+            number: 45, name: 'Fibonacci numbers', keyword: 'core,nonn,nice',
+            data: '0,1,1,2,3,5,8,13,21,34,55,89',
+            author: 'Sloane', created: '1991-04-30T03:00:00-04:00',
+        }];
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(() => Promise.resolve(new Response(JSON.stringify(result), { status: 200 }))));
+        const rows = await cmd.func({ query: 'fibonacci', limit: 1 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, id: 'A000045', name: 'Fibonacci numbers',
+            keywords: 'core,nonn,nice',
+            preview: '0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89',
+            url: 'https://oeis.org/A000045',
+        });
+    });
+});
+
+describe('oeis sequence adapter', () => {
+    const cmd = getRegistry().get('oeis/sequence');
+
+    it('rejects malformed sequence ids before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(cmd.func({ id: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'B000045' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'A' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('throws EmptyResultError when search returns null/empty list', async () => {
+        // OEIS returns empty list (or sometimes null body) for unknown id.
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([]), { status: 200 })));
+        await expect(cmd.func({ id: 'A9999999' })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('counts comments / formulas / xrefs without dumping the full graph', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify([{
+            number: 40, name: 'The prime numbers.', keyword: 'core,nonn',
+            data: '2,3,5,7,11,13,17,19,23',
+            offset: '1,1', author: 'Sloane', created: '1991-04-30T03:00:00-04:00', revision: 100,
+            comment: ['c1', 'c2', 'c3'],
+            formula: ['f1', 'f2'],
+            reference: ['r1'],
+            xref: ['A000001', 'A000002'],
+            link: ['l1', 'l2', 'l3', 'l4'],
+        }]), { status: 200 })));
+        const rows = await cmd.func({ id: 'A000040' });
+        expect(rows[0]).toMatchObject({
+            id: 'A000040', name: 'The prime numbers.',
+            termCount: 9, offset: '1,1', revision: 100,
+            commentCount: 3, formulaCount: 2, referenceCount: 1, xrefCount: 2, linkCount: 4,
+            url: 'https://oeis.org/A000040',
+        });
+    });
+});

package/clis/oeis/search.js

@@ -0,0 +1,63 @@
+// oeis search — keyword / pattern search against the OEIS index.
+//
+// OEIS' search supports both natural-language queries ("fibonacci") and
+// numeric pattern queries ("1,1,2,3,5,8"). Returns up to 10 results per
+// page; we honor `--limit` by paginating via `&start=`.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { OEIS_BASE, formatId, oeisFetch, previewTerms, requireBoundedInt, requireString } from './utils.js';
+
+cli({
+    site: 'oeis',
+    name: 'search',
+    access: 'read',
+    description: 'Search OEIS sequences by keyword or numeric pattern',
+    domain: 'oeis.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword or comma-separated terms (e.g. "fibonacci", "1,1,2,3,5,8")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max sequences (1-100)' },
+    ],
+    columns: ['rank', 'id', 'name', 'keywords', 'preview', 'author', 'created', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 10, 100);
+        // OEIS returns 10 per page; paginate via `&start=` until we have `limit` rows
+        // or run out of pages. No silent clamp — if upstream has fewer results, surface
+        // every row that came back.
+        const collected = [];
+        let start = 0;
+        const pageSize = 10;
+        // Cap iterations defensively at limit/pageSize + 1 so we never spin forever.
+        const maxPages = Math.ceil(limit / pageSize) + 1;
+        for (let page = 0; page < maxPages && collected.length < limit; page++) {
+            const url = `${OEIS_BASE}/search?q=${encodeURIComponent(query)}&fmt=json&start=${start}`;
+            const body = await oeisFetch(url, 'oeis search');
+            const list = Array.isArray(body) ? body : [];
+            if (!list.length) break;
+            for (const r of list) {
+                if (collected.length >= limit) break;
+                collected.push(r);
+            }
+            if (list.length < pageSize) break;
+            start += pageSize;
+        }
+        if (!collected.length) {
+            throw new EmptyResultError('oeis search', `No OEIS sequences matched "${query}".`);
+        }
+        return collected.map((r, i) => {
+            const id = formatId(r?.number);
+            return {
+                rank: i + 1,
+                id,
+                name: typeof r?.name === 'string' ? r.name : null,
+                keywords: typeof r?.keyword === 'string' ? r.keyword : null,
+                preview: previewTerms(r?.data),
+                author: typeof r?.author === 'string' ? r.author : null,
+                created: typeof r?.created === 'string' ? r.created : null,
+                url: id ? `${OEIS_BASE}/${id}` : '',
+            };
+        });
+    },
+});

package/clis/oeis/sequence.js

@@ -0,0 +1,71 @@
+// oeis sequence — full detail for a single OEIS sequence (A-number).
+//
+// OEIS' search endpoint, when given `q=id:Annnnnn`, returns one full record
+// with all sub-fields populated. We surface formula / xref / reference counts
+// instead of dumping the full graph.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { OEIS_BASE, formatId, oeisFetch, previewTerms, requireSequenceId } from './utils.js';
+
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+
+cli({
+    site: 'oeis',
+    name: 'sequence',
+    access: 'read',
+    description: 'Full OEIS sequence detail by A-number (terms, name, keywords, formula counts)',
+    domain: 'oeis.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'OEIS sequence id (e.g. "A000045" for Fibonacci)' },
+    ],
+    columns: [
+        'id',
+        'name',
+        'keywords',
+        'preview',
+        'termCount',
+        'offset',
+        'author',
+        'created',
+        'revision',
+        'commentCount',
+        'formulaCount',
+        'referenceCount',
+        'xrefCount',
+        'linkCount',
+        'url',
+    ],
+    func: async (args) => {
+        const id = requireSequenceId(args.id);
+        const url = `${OEIS_BASE}/search?q=id:${encodeURIComponent(id)}&fmt=json`;
+        const body = await oeisFetch(url, 'oeis sequence');
+        const list = Array.isArray(body) ? body : [];
+        if (!list.length) {
+            throw new EmptyResultError('oeis sequence', `OEIS sequence "${id}" not found.`);
+        }
+        const r = list[0];
+        const data = typeof r?.data === 'string' ? r.data : '';
+        const termCount = data ? data.split(',').filter(Boolean).length : 0;
+        return [{
+            id: formatId(r?.number) ?? id,
+            name: typeof r?.name === 'string' ? r.name : null,
+            keywords: typeof r?.keyword === 'string' ? r.keyword : null,
+            preview: previewTerms(data),
+            termCount,
+            offset: typeof r?.offset === 'string' ? r.offset : null,
+            author: typeof r?.author === 'string' ? r.author : null,
+            created: typeof r?.created === 'string' ? r.created : null,
+            revision: typeof r?.revision === 'number' ? r.revision : null,
+            commentCount: asArray(r?.comment).length,
+            formulaCount: asArray(r?.formula).length,
+            referenceCount: asArray(r?.reference).length,
+            xrefCount: asArray(r?.xref).length,
+            linkCount: asArray(r?.link).length,
+            url: `${OEIS_BASE}/${formatId(r?.number) ?? id}`,
+        }];
+    },
+});

package/clis/oeis/utils.js

@@ -0,0 +1,88 @@
+// Shared helpers for the OEIS adapter (Online Encyclopedia of Integer Sequences).
+//
+// OEIS exposes a single search endpoint that handles both keyword search and
+// id lookup via `q=id:Annnnnn`. JSON output via `fmt=json`. No API key.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const OEIS_BASE = 'https://oeis.org';
+const UA = 'opencli-oeis-adapter/1.0 (+https://github.com/jackwener/opencli; mailto:opencli@example.com)';
+
+// OEIS ids are A followed by 6 zero-padded digits (older entries use 6 by convention,
+// modern entries can be longer; OEIS itself accepts any digits after A).
+const SEQUENCE_ID_PATTERN = /^A\d{1,7}$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`oeis ${label} cannot be empty`);
+    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(`oeis ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`oeis ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requireSequenceId(value) {
+    const raw = String(value ?? '').trim().toUpperCase();
+    if (!raw) throw new ArgumentError('oeis sequence id is required (e.g. "A000045" for Fibonacci)');
+    // Tolerate common URL paste like `https://oeis.org/A000045`.
+    const stripped = raw.replace(/^HTTPS?:\/\/(?:WWW\.)?OEIS\.ORG\//, '').replace(/\/.*$/, '');
+    if (!SEQUENCE_ID_PATTERN.test(stripped)) {
+        throw new ArgumentError(
+            `oeis sequence id "${value}" is not a valid A-number`,
+            'Expected format: "A" + digits (e.g. "A000045").',
+        );
+    }
+    return stripped;
+}
+
+export async function oeisFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that oeis.org is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `OEIS returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(`${label} returned HTTP 429 (rate limited)`);
+    }
+    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;
+}
+
+/** Format OEIS' `number: 40` into the canonical zero-padded id `A000040`. */
+export function formatId(number) {
+    if (typeof number !== 'number' || !Number.isInteger(number) || number < 0) return null;
+    return `A${String(number).padStart(6, '0')}`;
+}
+
+/** Take the first N comma-separated terms from OEIS' `data` string. */
+export function previewTerms(data, max = 12) {
+    if (typeof data !== 'string') return '';
+    const terms = data.split(',').map((t) => t.trim()).filter(Boolean);
+    if (terms.length <= max) return terms.join(', ');
+    return [...terms.slice(0, max), `(+${terms.length - max})`].join(', ');
+}

package/clis/ones/login.js

@@ -4,6 +4,7 @@ import { getOnesBaseUrl, onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'login',
+    access: 'write',
     description: 'ONES Project API — login via Chrome Bridge (POST auth/login); stderr prints export hints for ONES_USER_ID / TOKEN',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/logout.js

@@ -3,6 +3,7 @@ import { onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'logout',
+    access: 'write',
     description: 'ONES Project API — invalidate current token (GET auth/logout) via Chrome Bridge',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/me.js

@@ -4,6 +4,7 @@ import { onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'me',
+    access: 'read',
     description: 'ONES Project API — current user (GET users/me) via Chrome Bridge',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/my-tasks.js

@@ -39,6 +39,7 @@ async function peekTasks(page, team, query, cap) {
 cli({
     site: 'ones',
     name: 'my-tasks',
+    access: 'read',
     description: 'ONES — my work items (filters/peek + strict must query). Default: assignee=me. Use --mode if your site uses field004 for assignee.',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/task.js

@@ -10,6 +10,7 @@ import { formatStamp } from './task-helpers.js';
 cli({
     site: 'ones',
     name: 'task',
+    access: 'read',
     description: 'ONES — work item detail (GET team/:team/task/:id/info); id is URL segment after …/task/',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/tasks.js

@@ -20,6 +20,7 @@ function buildQuery(project, assign) {
 cli({
     site: 'ones',
     name: 'tasks',
+    access: 'read',
     description: 'ONES Project API — list work items (POST team/:team/filters/peek); use token-info -f json for team uuid',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/token-info.js

@@ -4,6 +4,7 @@ import { onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'token-info',
+    access: 'read',
     description: 'ONES Project API — session detail (GET auth/token_info) via Chrome Bridge: user, teams, org',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/worklog.js

@@ -99,6 +99,7 @@ export function buildAddManhourGraphqlBody(input) {
 cli({
     site: 'ones',
     name: 'worklog',
+    access: 'write',
     description: 'ONES — log work hours on a task (defaults to today; use --date to backfill; endpoint falls back by deployment).',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/openalex/search.js

@@ -0,0 +1,69 @@
+// openalex search — search OpenAlex's Works index by free text.
+//
+// Hits `https://api.openalex.org/works?search=…&per-page=…`. Returns the
+// agent-useful projection: OpenAlex Work id (round-trips into `openalex
+// work`), DOI, title, year, citation count, first author, primary venue,
+// open-access status.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    OPENALEX_BASE,
+    appendMailto,
+    bareDoi,
+    bareId,
+    openalexFetch,
+    requireBoundedInt,
+    requireString,
+} from './utils.js';
+
+const SELECT_FIELDS = [
+    'id', 'doi', 'title', 'publication_year', 'publication_date',
+    'cited_by_count', 'authorships', 'primary_location', 'open_access', 'type',
+].join(',');
+
+cli({
+    site: 'openalex',
+    name: 'search',
+    access: 'read',
+    description: 'Search OpenAlex Works (papers, books, preprints) by keyword',
+    domain: 'api.openalex.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search text (e.g. "transformers", "open access scholarly")' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max works (1-200, single OpenAlex page)' },
+    ],
+    columns: ['rank', 'id', 'title', 'year', 'citations', 'firstAuthor', 'venue', 'openAccess', 'type', 'doi', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 20, 200);
+        const url = appendMailto(
+            `${OPENALEX_BASE}/works?search=${encodeURIComponent(query)}&per-page=${limit}&select=${SELECT_FIELDS}`,
+        );
+        const body = await openalexFetch(url, 'openalex search');
+        const list = Array.isArray(body?.results) ? body.results : [];
+        if (!list.length) {
+            throw new EmptyResultError('openalex search', `No OpenAlex works matched "${query}".`);
+        }
+        return list.slice(0, limit).map((w, i) => {
+            const firstAuthor = Array.isArray(w.authorships) && w.authorships.length
+                ? String(w.authorships[0]?.author?.display_name ?? '').trim()
+                : '';
+            const venue = String(w.primary_location?.source?.display_name ?? '').trim();
+            const id = bareId(w.id);
+            return {
+                rank: i + 1,
+                id,
+                title: String(w.title ?? '').trim(),
+                year: w.publication_year != null ? Number(w.publication_year) : null,
+                citations: w.cited_by_count != null ? Number(w.cited_by_count) : null,
+                firstAuthor,
+                venue,
+                openAccess: Boolean(w.open_access?.is_oa),
+                type: String(w.type ?? '').trim(),
+                doi: bareDoi(w.doi),
+                url: id ? `https://openalex.org/${id}` : '',
+            };
+        });
+    },
+});