@jackwener/opencli 1.7.12 → 1.7.13

package/clis/defillama/protocols.js

@@ -0,0 +1,55 @@
+// defillama protocols — top DeFi protocols by current TVL.
+//
+// Hits `https://api.llama.fi/protocols`, sorts by TVL (desc), and returns the
+// requested top-N. The API ships ~7400 entries today; we cap output at 500
+// rows so agents do not paginate their entire DeFi universe by accident.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { LLAMA_BASE, llamaFetch, requireBoundedInt, unixToDate } from './utils.js';
+
+cli({
+    site: 'defillama',
+    name: 'protocols',
+    access: 'read',
+    description: 'Top DeFi protocols on DefiLlama by current TVL (slug, name, category, TVL, mcap, change_1d/7d, chains)',
+    domain: 'defillama.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 30, help: 'Number of rows to return (1-500)' },
+    ],
+    columns: [
+        'rank', 'slug', 'name', 'category', 'tvl', 'mcap',
+        'change_1d', 'change_7d', 'chains', 'listedAt', 'url',
+    ],
+    func: async (args) => {
+        const limit = requireBoundedInt(args.limit, 30, 500, 'limit');
+        const list = await llamaFetch(`${LLAMA_BASE}/protocols`, 'defillama protocols');
+        if (!Array.isArray(list) || list.length === 0) {
+            throw new EmptyResultError('defillama protocols', 'DefiLlama returned no protocol entries.');
+        }
+        const ranked = list
+            .filter((p) => p && (p.slug || p.name) && Number.isFinite(Number(p.tvl)))
+            .sort((a, b) => Number(b.tvl) - Number(a.tvl))
+            .slice(0, limit);
+        if (ranked.length === 0) {
+            throw new EmptyResultError('defillama protocols', 'DefiLlama returned no protocols with numeric TVL.');
+        }
+        return ranked.map((p, i) => {
+            const slug = String(p.slug ?? '').trim();
+            return {
+                rank: i + 1,
+                slug,
+                name: String(p.name ?? '').trim(),
+                category: String(p.category ?? '').trim(),
+                tvl: Number(p.tvl),
+                mcap: p.mcap == null ? null : Number(p.mcap),
+                change_1d: p.change_1d == null ? null : Number(p.change_1d),
+                change_7d: p.change_7d == null ? null : Number(p.change_7d),
+                chains: Array.isArray(p.chains) ? p.chains.join(', ') : '',
+                listedAt: unixToDate(p.listedAt),
+                url: slug ? `https://defillama.com/protocol/${slug}` : '',
+            };
+        });
+    },
+});

package/clis/defillama/utils.js

@@ -0,0 +1,99 @@
+// Shared helpers for the DefiLlama adapters.
+//
+// DefiLlama serves a public REST API (no auth) over https://api.llama.fi.
+// Docs: https://defillama.com/docs/api
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const LLAMA_BASE = 'https://api.llama.fi';
+const UA = 'opencli-defillama-adapter (+https://github.com/jackwener/opencli)';
+
+// DefiLlama slugs are lowercase with hyphens / digits / dots; allow up to 100 chars.
+const SLUG = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`defillama ${label} cannot be empty`);
+    return s;
+}
+
+export function requireSlug(value, label = 'slug') {
+    const s = String(value ?? '').trim();
+    if (!s) {
+        throw new ArgumentError(
+            `defillama ${label} is required (e.g. "aave", "lido")`,
+            'Use the protocol slug as it appears on https://defillama.com/protocol/<slug>.',
+        );
+    }
+    if (!SLUG.test(s)) {
+        throw new ArgumentError(
+            `defillama ${label} "${value}" is not a valid DefiLlama slug`,
+            'Slugs are lowercase ASCII (letters / digits / "._-"), e.g. "aave", "lido", "pancakeswap-amm".',
+        );
+    }
+    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(`defillama ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`defillama ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function llamaFetch(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.llama.fi is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `DefiLlama returned 404 for ${url}.`);
+    }
+    if (resp.status === 400) {
+        // DefiLlama returns 400 + plain-text "Protocol not found" for unknown slugs.
+        const body = await resp.text().catch(() => '');
+        if (/not\s*found/i.test(body)) {
+            throw new EmptyResultError(label, `DefiLlama: ${body.trim() || 'not found'}.`);
+        }
+        throw new CommandExecutionError(`${label} returned HTTP 400: ${body.slice(0, 200)}`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'DefiLlama throttles unauthenticated traffic; wait a few seconds and retry.',
+        );
+    }
+    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;
+}
+
+// Convert a unix-seconds timestamp (DefiLlama's listedAt convention) to YYYY-MM-DD,
+// or null when the value is missing / not a finite number.
+export function unixToDate(value) {
+    if (value == null) return null;
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    const ms = n > 1e12 ? n : n * 1000;
+    const d = new Date(ms);
+    if (Number.isNaN(d.getTime())) return null;
+    return d.toISOString().slice(0, 10);
+}

package/clis/devto/latest.js

@@ -0,0 +1,74 @@
+// devto latest — newest dev.to articles, regardless of tag.
+//
+// Hits the public `/api/articles/latest` endpoint. Complements the existing
+// `devto top` (most-reactioned) and `devto tag` (filtered) commands by
+// surfacing the firehose of brand-new posts.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+function requireBoundedInt(value, defaultValue, maxValue) {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError('devto limit must be a positive integer');
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`devto limit must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+cli({
+    site: 'devto',
+    name: 'latest',
+    access: 'read',
+    description: 'Newest dev.to articles (firehose, all tags)',
+    domain: 'dev.to',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Articles per page (1-100)' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number (1-based)' },
+    ],
+    columns: ['rank', 'id', 'title', 'author', 'tags', 'reactions', 'comments', 'published', 'url'],
+    func: async (args) => {
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const page = requireBoundedInt(args.page, 1, 1000);
+        const url = `https://dev.to/api/articles/latest?per_page=${limit}&page=${page}`;
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { accept: 'application/json' } });
+        }
+        catch (err) {
+            throw new CommandExecutionError(
+                `devto latest request failed: ${err?.message ?? err}`,
+                'Check that dev.to is reachable from this network.',
+            );
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`devto latest returned HTTP ${resp.status}`);
+        }
+        let body;
+        try {
+            body = await resp.json();
+        }
+        catch (err) {
+            throw new CommandExecutionError(`devto latest returned malformed JSON: ${err?.message ?? err}`);
+        }
+        const list = Array.isArray(body) ? body : [];
+        if (!list.length) {
+            throw new EmptyResultError('devto latest', `dev.to /articles/latest returned no items at page ${page}.`);
+        }
+        return list.map((item, i) => ({
+            rank: (page - 1) * limit + i + 1,
+            id: item.id != null ? String(item.id) : '',
+            title: String(item.title ?? ''),
+            author: String(item?.user?.username ?? ''),
+            tags: String(item.tag_list ?? '').replace(/,\s*/g, ', '),
+            reactions: item.public_reactions_count != null ? Number(item.public_reactions_count) : null,
+            comments: item.comments_count != null ? Number(item.comments_count) : null,
+            published: String(item.published_at ?? '').slice(0, 10),
+            url: String(item.url ?? ''),
+        }));
+    },
+});

package/clis/dockerhub/image.js

@@ -0,0 +1,52 @@
+// dockerhub image — fetch a single Docker Hub repository's metadata.
+//
+// Hits `https://hub.docker.com/v2/repositories/<owner>/<name>`. Bare names
+// resolve to the implicit `library` owner used for Docker official images
+// (so `dockerhub image nginx` ≡ `dockerhub image library/nginx`). Returns a
+// one-row projection: official-flag, star / pull counters, last-updated /
+// registered timestamps, repo status, short description, hub URL.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { HUB_BASE, hubFetch, parseImage } from './utils.js';
+
+function trimDate(value) {
+    const s = String(value ?? '').trim();
+    if (!s) return null;
+    // Docker Hub returns mixed precision (`...45Z` and `...35.286495Z`). Drop
+    // the fractional part so all timestamp columns share `YYYY-MM-DDTHH:MM:SSZ`.
+    const noFrac = s.replace(/\.\d+/, '');
+    return noFrac.endsWith('Z') ? noFrac : `${noFrac}Z`;
+}
+
+cli({
+    site: 'dockerhub',
+    name: 'image',
+    access: 'read',
+    description: 'Fetch a Docker Hub repository\'s public metadata (stars, pulls, last updated, status)',
+    domain: 'hub.docker.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'image', positional: true, required: true, help: 'Image name (e.g. "nginx", "library/nginx", "bitnami/redis")' },
+    ],
+    columns: ['image', 'official', 'stars', 'pulls', 'description', 'lastUpdated', 'lastModified', 'registered', 'status', 'url'],
+    func: async (args) => {
+        const { owner, name } = parseImage(args.image);
+        const url = `${HUB_BASE}/repositories/${owner}/${name}/`;
+        const body = await hubFetch(url, 'dockerhub image');
+        const namespace = String(body?.namespace ?? owner).trim();
+        const isOfficial = namespace === 'library' || namespace === '_';
+        const image = isOfficial ? `library/${name}` : `${namespace}/${name}`;
+        return [{
+            image,
+            official: isOfficial,
+            stars: body?.star_count != null ? Number(body.star_count) : null,
+            pulls: body?.pull_count != null ? Number(body.pull_count) : null,
+            description: String(body?.description ?? '').trim(),
+            lastUpdated: trimDate(body?.last_updated),
+            lastModified: trimDate(body?.last_modified),
+            registered: trimDate(body?.date_registered),
+            status: String(body?.status_description ?? '').trim(),
+            url: `https://hub.docker.com/r/${image}`,
+        }];
+    },
+});

package/clis/dockerhub/search.js

@@ -0,0 +1,47 @@
+// dockerhub search — search the public Docker Hub repository index.
+//
+// Hits `https://hub.docker.com/v2/search/repositories/?query=…`. Returns the
+// agent-useful projection: official-flag, owner/name (round-trips into
+// `dockerhub image`), star count, pull count, short description.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { HUB_BASE, hubFetch, requireBoundedInt, requireString } from './utils.js';
+
+cli({
+    site: 'dockerhub',
+    name: 'search',
+    access: 'read',
+    description: 'Search Docker Hub repositories by keyword',
+    domain: 'hub.docker.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "nginx", "bitnami redis")' },
+        { name: 'limit', type: 'int', default: 25, help: 'Max repositories (1-100, single Docker Hub page)' },
+    ],
+    columns: ['rank', 'image', 'official', 'stars', 'pulls', 'description', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 25, 100);
+        const url = `${HUB_BASE}/search/repositories/?query=${encodeURIComponent(query)}&page_size=${limit}`;
+        const body = await hubFetch(url, 'dockerhub search');
+        const list = Array.isArray(body?.results) ? body.results : [];
+        if (!list.length) {
+            throw new EmptyResultError('dockerhub search', `No Docker Hub repositories matched "${query}".`);
+        }
+        return list.slice(0, limit).map((r, i) => {
+            const owner = String(r.repo_owner ?? '').trim();
+            const name = String(r.repo_name ?? '').trim();
+            const image = owner ? `${owner}/${name}` : (r.is_official ? `library/${name}` : name);
+            return {
+                rank: i + 1,
+                image,
+                official: Boolean(r.is_official),
+                stars: r.star_count != null ? Number(r.star_count) : null,
+                pulls: r.pull_count != null ? Number(r.pull_count) : null,
+                description: String(r.short_description ?? '').trim(),
+                url: image ? `https://hub.docker.com/r/${image}` : '',
+            };
+        });
+    },
+});

package/clis/dockerhub/utils.js

@@ -0,0 +1,100 @@
+// Shared helpers for the Docker Hub adapters.
+//
+// Hits the public, unauthenticated `hub.docker.com/v2` REST endpoints. Anonymous
+// pulls are throttled but search / metadata reads are friendly enough for
+// ad-hoc CLI use. Image names follow `[<owner>/]<name>` with `library` as the
+// implicit owner for Docker official images.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const HUB_BASE = 'https://hub.docker.com/v2';
+const UA = 'opencli-dockerhub-adapter (+https://github.com/jackwener/opencli)';
+
+// Docker Hub repository slugs are 2-255 chars, lowercase alphanumerics + `_.-`,
+// optionally prefixed with a Docker Hub user/org of the same charset.
+const SLUG = /^[a-z0-9][a-z0-9._-]*$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`dockerhub ${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(`dockerhub ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`dockerhub ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+/**
+ * Split an image identifier into `{owner, name}`. Bare names use the implicit
+ * `library` owner that Docker Hub uses for official images (`nginx` →
+ * `library/nginx`).
+ */
+export function parseImage(input) {
+    const raw = String(input ?? '').trim().toLowerCase();
+    if (!raw) {
+        throw new ArgumentError('dockerhub image name is required (e.g. "nginx", "library/nginx", "bitnami/redis")');
+    }
+    const slash = raw.indexOf('/');
+    let owner;
+    let name;
+    if (slash >= 0) {
+        owner = raw.slice(0, slash);
+        name = raw.slice(slash + 1);
+    }
+    else {
+        owner = 'library';
+        name = raw;
+    }
+    if (!SLUG.test(owner) || !SLUG.test(name)) {
+        throw new ArgumentError(
+            `dockerhub image "${input}" is not a valid repository slug`,
+            'Use lowercase letters / digits / "._-", optionally prefixed with "<owner>/".',
+        );
+    }
+    if (name.length < 2 || name.length > 255) {
+        throw new ArgumentError(
+            `dockerhub image "${input}" name must be 2-255 chars`,
+        );
+    }
+    return { owner, name };
+}
+
+export async function hubFetch(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 hub.docker.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `Docker Hub returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'Docker Hub throttles anonymous traffic; wait a few seconds and retry.',
+        );
+    }
+    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/doubao/ask.js

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
 import { DOUBAO_DOMAIN, getDoubaoTranscriptLines, getDoubaoVisibleTurns, sendDoubaoMessage, waitForDoubaoResponse } from './utils.js';
 export const askCommand = cli({
     site: 'doubao',
@@ -8,16 +9,19 @@ export const askCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
-    timeoutSeconds: 180,
     args: [
         { name: 'text', required: true, positional: true, help: 'Prompt to send' },
-        { name: 'timeout', required: false, help: 'Max seconds to wait (default: 60)', default: '60' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait (default: 60)', default: 60 },
     ],
     columns: ['Role', 'Text'],
     func: async (page, kwargs) => {
         const text = kwargs.text;
-        const timeout = parseInt(kwargs.timeout, 10) || 60;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
         const beforeTurns = await getDoubaoVisibleTurns(page);
         const beforeLines = await getDoubaoTranscriptLines(page);
         await sendDoubaoMessage(page, text);

package/clis/doubao/detail.js

@@ -8,6 +8,7 @@ export const detailCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'id', required: true, positional: true, help: 'Conversation ID (numeric or full URL)' },

package/clis/doubao/history.js

@@ -8,6 +8,7 @@ export const historyCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'limit', required: false, help: 'Max number of conversations to show', default: '50' },

package/clis/doubao/meeting-summary.js

@@ -8,6 +8,7 @@ export const meetingSummaryCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'id', required: true, positional: true, help: 'Conversation ID (numeric or full URL)' },

package/clis/doubao/meeting-transcript.js

@@ -8,6 +8,7 @@ export const meetingTranscriptCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'id', required: true, positional: true, help: 'Conversation ID (numeric or full URL)' },

package/clis/doubao/new.js

@@ -8,6 +8,7 @@ export const newCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Action'],

package/clis/doubao/read.js

@@ -8,6 +8,7 @@ export const readCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Role', 'Text'],

package/clis/doubao/send.js

@@ -8,6 +8,7 @@ export const sendCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
     columns: ['Status', 'SubmittedBy', 'InjectedText'],

package/clis/doubao/status.js

@@ -8,6 +8,7 @@ export const statusCommand = cli({
     domain: DOUBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Login', 'Url', 'Title'],

package/clis/douyin/draft.test.js

@@ -5,6 +5,7 @@ import { afterAll, describe, expect, it, vi } from 'vitest';
 import { wrapForEval } from '@jackwener/opencli/browser/utils';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { buildCoverCheckPanelTextJs } from './draft.js';
+import { createPageMock } from '../test-utils.js';
 // ─── Shared test helpers ────────────────────────────────────────────
 const tempDirs = [];
 function createTempVideo(name = 'demo.mp4') {
@@ -49,36 +50,6 @@ function createFakeTree(text, children = []) {
     }
     return node;
 }
-function createPageMock(evaluateResults, overrides = {}) {
-    const evaluate = vi.fn();
-    for (const result of evaluateResults) {
-        evaluate.mockResolvedValueOnce(result);
-    }
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate,
-        getCookies: vi.fn().mockResolvedValue([]),
-        snapshot: vi.fn().mockResolvedValue(undefined),
-        click: vi.fn().mockResolvedValue(undefined),
-        typeText: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-        scrollTo: vi.fn().mockResolvedValue(undefined),
-        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
-        wait: vi.fn().mockResolvedValue(undefined),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn().mockResolvedValue(undefined),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue([]),
-        scroll: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        installInterceptor: vi.fn().mockResolvedValue(undefined),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        screenshot: vi.fn().mockResolvedValue(''),
-        setFileInput: vi.fn().mockResolvedValue(undefined),
-        ...overrides,
-    };
-}
 describe('douyin draft registration', () => {
     it('registers the draft command', () => {
         const registry = getRegistry();

package/clis/endoflife/endoflife.test.js

@@ -0,0 +1,51 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './product.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('endoflife product adapter', () => {
+    const cmd = getRegistry().get('endoflife/product');
+
+    it('rejects empty / malformed product before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ product: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ product: 'BAD/PRODUCT' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        await expect(cmd.func({ product: 'nodejs' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('maps HTTP 404 to EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
+        await expect(cmd.func({ product: 'no-such-product' })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('normalises lts/support/eol booleans + dates and projects eolStatus', async () => {
+        const cycles = [
+            { cycle: '24', releaseDate: '2025-05-06', latest: '24.15.0', latestReleaseDate: '2026-04-15', lts: '2025-10-28', support: '2026-10-20', eol: '2028-04-30', extendedSupport: false },
+            { cycle: '20', releaseDate: '2023-04-18', latest: '20.20.2', latestReleaseDate: '2026-03-24', lts: '2023-10-24', support: '2024-10-22', eol: '2026-04-30', extendedSupport: true },
+            { cycle: 'rolling', releaseDate: '2020-01-01', latest: 'next', latestReleaseDate: '2026-01-01', lts: false, support: true, eol: false, extendedSupport: false },
+        ];
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(cycles), { status: 200 })));
+
+        const rows = await cmd.func({ product: 'nodejs' });
+        expect(rows).toHaveLength(3);
+        // Future eol -> active
+        expect(rows[0]).toMatchObject({ product: 'nodejs', cycle: '24', eol: '2028-04-30', eolStatus: 'active' });
+        expect(rows[1]).toMatchObject({ cycle: '20', eol: '2026-04-30', eolStatus: 'eol' });
+        // Boolean true -> "ongoing"; boolean false -> null
+        expect(rows[2]).toMatchObject({ cycle: 'rolling', lts: null, support: 'ongoing', eol: null, eolStatus: null });
+        // Round-trip: product is the slug into endoflife.date URLs
+        expect(rows[0].url).toBe('https://endoflife.date/nodejs');
+    });
+});