@agentrhq/webcmd 0.1.2 → 0.2.1

package/clis/kimi/storage.js

@@ -1,169 +0,0 @@
-// Browser-side state on kimi.com (analog to Grok's storage commands).
-//
-//   storage-keys [--storage local|session] [--filter]
-//   storage-get <key> [--storage] [--max-bytes]
-//   cookies         — list JS-visible cookies
-//   idb-list        — list IndexedDB databases on kimi.com
-
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import {
-    ArgumentError,
-    CommandExecutionError,
-    EmptyResultError,
-} from '@agentrhq/webcmd/errors';
-import { KIMI_DOMAIN, ensureOnKimi } from './_utils.js';
-
-const STORAGE_COLUMNS = ['Field', 'Value', 'Index', 'Key', 'Bytes', 'Name', 'Preview', 'Database', 'Version'];
-
-function pickStore(args) {
-    const s = String(args?.storage || 'local').trim().toLowerCase();
-    if (s !== 'local' && s !== 'session') {
-        throw new ArgumentError('storage', 'must be "local" or "session"');
-    }
-    return s === 'session' ? 'sessionStorage' : 'localStorage';
-}
-
-// -------- storage-keys --------
-cli({
-    site: 'kimi',
-    name: 'storage-keys',
-    access: 'read',
-    description: 'List localStorage / sessionStorage keys on kimi.com (with byte sizes).',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [
-        { name: 'storage', required: false, default: 'local', help: '"local" or "session"' },
-        { name: 'filter', required: false, help: 'Case-insensitive substring filter over keys' },
-        { name: 'limit', type: 'int', required: false, default: 100 },
-    ],
-    columns: STORAGE_COLUMNS,
-    func: async (page, kwargs) => {
-        await ensureOnKimi(page);
-        const store = pickStore(kwargs);
-        const raw = await page.evaluate(`(() => {
-      const s = ${store};
-      const out = [];
-      for (let i = 0; i < s.length; i++) {
-        const k = s.key(i);
-        const v = s.getItem(k) || '';
-        out.push({ k, bytes: v.length });
-      }
-      return out;
-    })()`);
-        const flt = kwargs?.filter ? String(kwargs.filter).toLowerCase() : null;
-        const filtered = flt ? raw.filter((r) => r.k.toLowerCase().includes(flt)) : raw;
-        if (!filtered.length) {
-            throw new EmptyResultError('kimi storage-keys', flt ? `No keys match "${flt}".` : `${store} is empty.`);
-        }
-        filtered.sort((a, b) => a.k.localeCompare(b.k));
-        const limit = Number.isInteger(kwargs?.limit) && kwargs.limit > 0 ? kwargs.limit : 100;
-        return filtered.slice(0, limit).map((r, i) => ({ Index: i + 1, Key: r.k, Bytes: r.bytes }));
-    },
-});
-
-// -------- storage-get --------
-cli({
-    site: 'kimi',
-    name: 'storage-get',
-    access: 'read',
-    description: 'Read a single localStorage / sessionStorage value on kimi.com. Auto-decodes JSON.',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [
-        { name: 'key', positional: true, required: true, help: 'Storage key' },
-        { name: 'storage', required: false, default: 'local' },
-        { name: 'max-bytes', type: 'int', required: false, default: 4000 },
-    ],
-    columns: STORAGE_COLUMNS,
-    func: async (page, kwargs) => {
-        const key = String(kwargs?.key || '').trim();
-        if (!key) throw new ArgumentError('key', 'is required');
-        await ensureOnKimi(page);
-        const store = pickStore(kwargs);
-        const raw = await page.evaluate(`${store}.getItem(${JSON.stringify(key)})`);
-        if (raw === null || raw === undefined) {
-            throw new CommandExecutionError(`Key not found in ${store}: ${key}`, '');
-        }
-        const max = Number.isInteger(kwargs['max-bytes']) && kwargs['max-bytes'] > 0 ? kwargs['max-bytes'] : 4000;
-        let parsed = raw;
-        let kind = 'string';
-        try {
-            parsed = JSON.parse(raw);
-            kind = Array.isArray(parsed) ? 'array' : typeof parsed;
-        } catch {}
-        const text = kind === 'string' ? parsed : JSON.stringify(parsed, null, 2);
-        const truncated = text.length > max;
-        return [
-            { Field: 'Key', Value: key },
-            { Field: 'Store', Value: store },
-            { Field: 'Type', Value: kind },
-            { Field: 'Size', Value: `${text.length} chars${truncated ? ' (truncated)' : ''}` },
-            { Field: 'Value', Value: truncated ? text.slice(0, max) + '\n...(truncated)' : text },
-        ];
-    },
-});
-
-// -------- cookies --------
-cli({
-    site: 'kimi',
-    name: 'cookies',
-    access: 'read',
-    description: 'List kimi.com cookies visible to JavaScript (httpOnly cookies are deliberately not shown).',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [],
-    columns: STORAGE_COLUMNS,
-    func: async (page) => {
-        await ensureOnKimi(page);
-        const raw = await page.evaluate('document.cookie');
-        if (!raw) {
-            throw new EmptyResultError('kimi cookies', 'document.cookie is empty (likely all cookies are httpOnly).');
-        }
-        const cookies = raw.split('; ').map((pair) => {
-            const idx = pair.indexOf('=');
-            if (idx < 0) return { name: pair, value: '' };
-            return { name: pair.slice(0, idx), value: pair.slice(idx + 1) };
-        });
-        return cookies.map((c, i) => ({
-            Index: i + 1,
-            Name: c.name,
-            Bytes: c.value.length,
-            Preview: c.value.slice(0, 40) + (c.value.length > 40 ? '…' : ''),
-        }));
-    },
-});
-
-// -------- idb-list --------
-cli({
-    site: 'kimi',
-    name: 'idb-list',
-    access: 'read',
-    description: 'List IndexedDB databases on kimi.com.',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [],
-    columns: STORAGE_COLUMNS,
-    func: async (page) => {
-        await ensureOnKimi(page);
-        const dbs = await page.evaluate(`(async () => {
-      if (!indexedDB.databases) return [];
-      return await indexedDB.databases();
-    })()`);
-        if (!Array.isArray(dbs) || !dbs.length) {
-            throw new EmptyResultError('kimi idb-list', 'No IndexedDB databases.');
-        }
-        return dbs.map((d, i) => ({ Index: i + 1, Database: d.name || '(unnamed)', Version: String(d.version || '') }));
-    },
-});

package/clis/kimi/ui.js

@@ -1,314 +0,0 @@
-// Sidebar / mode-navigation commands for Kimi.
-
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import {
-    ArgumentError,
-    CommandExecutionError,
-    EmptyResultError,
-} from '@agentrhq/webcmd/errors';
-import {
-    KIMI_DOMAIN,
-    KIMI_URL,
-    IS_VISIBLE_JS,
-    ensureOnKimi,
-    clickBySvgNameScript,
-    navByHrefScript,
-} from './_utils.js';
-
-const UI_COLUMNS = ['Mode', 'Status', 'Url', 'Field', 'Value', 'Index', 'Model', 'Active'];
-
-// Kimi exposes 7 specialized work modes via sidebar links.
-// Mapping: cli name → URL hash
-const MODES = {
-    ppt: '/slides',
-    docs: '/docs',
-    'deep-research': '/deep-research',
-    websites: '/websites',
-    sheets: '/sheets',
-    'agent-swarm': '/agent-swarm',
-    code: '/code',
-};
-
-// -------- mode --------
-cli({
-    site: 'kimi',
-    name: 'mode',
-    access: 'write',
-    description: 'Switch to a Kimi work mode: ppt | docs | deep-research | websites | sheets | agent-swarm | code. With no argument, lists modes.',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [
-        { name: 'name', positional: true, required: false, help: 'Mode name (omit to list all)' },
-    ],
-    columns: UI_COLUMNS,
-    func: async (page, kwargs) => {
-        const name = String(kwargs?.name || '').trim().toLowerCase();
-        if (!name) {
-            return Object.entries(MODES).map(([m, url]) => ({
-                Mode: m,
-                Status: 'available',
-                Url: KIMI_URL + url.slice(1),
-            }));
-        }
-        const target = MODES[name];
-        if (!target) {
-            throw new ArgumentError('name', `unknown mode "${name}". Known: ${Object.keys(MODES).join(', ')}`);
-        }
-        await ensureOnKimi(page);
-        await page.goto(`${KIMI_URL}${target.slice(1)}`);
-        await page.wait(1);
-        const url = await page.evaluate('window.location.href');
-        return [{ Mode: name, Status: 'navigated', Url: String(url || '') }];
-    },
-});
-
-// -------- sidebar-toggle --------
-cli({
-    site: 'kimi',
-    name: 'sidebar-toggle',
-    access: 'write',
-    description: 'Click the LeftBar svg to toggle the Kimi sidebar.',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [],
-    columns: UI_COLUMNS,
-    func: async (page) => {
-        await ensureOnKimi(page);
-        const res = await page.evaluate(clickBySvgNameScript('LeftBar', { last: false }));
-        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'LeftBar svg not visible', '');
-        return [{ Status: 'toggled' }];
-    },
-});
-
-// -------- view-all-history --------
-cli({
-    site: 'kimi',
-    name: 'view-all-history',
-    access: 'write',
-    description: 'Navigate to /chat/history (full conversation list page).',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [],
-    columns: UI_COLUMNS,
-    func: async (page) => {
-        await page.goto(`${KIMI_URL}chat/history`);
-        await page.wait(1);
-        const url = await page.evaluate('window.location.href');
-        return [{ Status: 'navigated', Url: String(url || '') }];
-    },
-});
-
-// -------- settings --------
-cli({
-    site: 'kimi',
-    name: 'settings',
-    access: 'write',
-    description: 'Open the Kimi settings page (/settings).',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [],
-    columns: UI_COLUMNS,
-    func: async (page) => {
-        await page.goto(`${KIMI_URL}settings`);
-        await page.wait(1);
-        const url = await page.evaluate('window.location.href');
-        return [{ Status: 'navigated', Url: String(url || '') }];
-    },
-});
-
-// -------- account --------
-cli({
-    site: 'kimi',
-    name: 'account',
-    access: 'read',
-    description: 'Read account info from the Kimi sidebar (display name + plan label, e.g. "Allegretto").',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [],
-    columns: UI_COLUMNS,
-    func: async (page) => {
-        await ensureOnKimi(page);
-        const data = await page.evaluate(`(() => {
-      ${IS_VISIBLE_JS}
-      const avatar = document.querySelector('img[src*="avatar.moonshot.cn"]');
-      if (!avatar) return null;
-      // The display name + plan are siblings in a parent container.
-      let container = avatar;
-      for (let i = 0; i < 5; i++) { if (container.parentElement) container = container.parentElement; }
-      const spans = Array.from(container.querySelectorAll('span, div')).filter(isVisible)
-        .map((el) => (el.innerText || el.textContent || '').trim())
-        .filter((t) => t && t.length < 60);
-      const uniq = [...new Set(spans)];
-      return {
-        avatarUrl: avatar.src,
-        avatarAlt: avatar.alt || '',
-        labels: uniq.slice(0, 10),
-      };
-    })()`);
-        if (!data) {
-            throw new CommandExecutionError('No avatar found — not logged in?', '');
-        }
-        const rows = [
-            { Field: 'AvatarAlt', Value: data.avatarAlt || '(none)' },
-            { Field: 'AvatarUrl', Value: data.avatarUrl },
-        ];
-        data.labels.forEach((l, i) => rows.push({ Field: `Label[${i + 1}]`, Value: l }));
-        return rows;
-    },
-});
-
-// -------- model --------
-cli({
-    site: 'kimi',
-    name: 'model',
-    access: 'write',
-    description: 'Read the current Kimi model (e.g. "K2.6 思考") or switch by clicking the model dropdown. With no argument, returns current; with --list, opens dropdown + lists; with --set <name>, switches.',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [
-        { name: 'list', type: 'boolean', default: false, help: 'Open model dropdown + list options' },
-        { name: 'set', required: false, help: 'Substring (case-insensitive) of model to switch to' },
-    ],
-    columns: UI_COLUMNS,
-    func: async (page, kwargs) => {
-        await ensureOnKimi(page);
-        const wantList = kwargs?.list === true || kwargs?.list === 'true';
-        const wantSet = String(kwargs?.set || '').trim();
-
-        // Read current model label from the composer toolbar.
-        const cur = await page.evaluate(`(() => {
-      ${IS_VISIBLE_JS}
-      // The model button is a div containing a Down_b svg + a span with model name.
-      const svgs = Array.from(document.querySelectorAll('svg[name="Down_b"]')).filter(isVisible);
-      for (const svg of svgs) {
-        let p = svg.parentElement;
-        for (let i = 0; i < 4 && p; i++) {
-          const spans = p.querySelectorAll('span');
-          for (const s of spans) {
-            const t = (s.textContent || '').trim();
-            if (/^K\\d|^Kimi |^Pro\\b|^Auto/.test(t)) return t;
-          }
-          p = p.parentElement;
-        }
-      }
-      return '';
-    })()`);
-        if (!wantList && !wantSet) {
-            return [{ Index: 1, Model: cur || '(unknown)', Active: 'yes' }];
-        }
-
-        // Open the dropdown by clicking the Down_b svg next to the model name.
-        await page.evaluate(`(() => {
-      ${IS_VISIBLE_JS}
-      const svgs = Array.from(document.querySelectorAll('svg[name="Down_b"]')).filter(isVisible);
-      // The model trigger is usually the one with a sibling span starting with "K"
-      for (const svg of svgs) {
-        let p = svg.parentElement;
-        for (let i = 0; i < 4 && p; i++) {
-          const spans = p.querySelectorAll('span');
-          const match = Array.from(spans).find((s) => /^K\\d|^Kimi |^Pro\\b|^Auto/.test((s.textContent || '').trim()));
-          if (match) {
-            p.click();
-            return;
-          }
-          p = p.parentElement;
-        }
-      }
-    })()`);
-        await page.wait(0.5);
-        const opts = await page.evaluate(`(() => {
-      ${IS_VISIBLE_JS}
-      // Dropdown items appear in a floating popover.
-      const popovers = Array.from(document.querySelectorAll('[class*="popover"i], [class*="dropdown"i], [role="menu"], [role="listbox"]')).filter(isVisible)
-        .filter((el) => { const r = el.getBoundingClientRect(); return r.width < 600 && r.height < 600; });
-      if (!popovers.length) return [];
-      const pop = popovers[popovers.length - 1];
-      return Array.from(pop.querySelectorAll('div, li, button, [role="option"], [role="menuitem"]'))
-        .filter(isVisible)
-        .map((el) => (el.innerText || el.textContent || '').trim().replace(/\\s+/g, ' '))
-        .filter((t) => t && t.length < 80 && (/K\\d|Kimi|Pro\\b|Auto|思考/.test(t)))
-        .filter((t, i, arr) => arr.indexOf(t) === i)
-        .slice(0, 20);
-    })()`);
-
-        if (wantSet) {
-            const normalizeModel = (value) => String(value || '').toLowerCase().replace(/[^a-z0-9.\u4e00-\u9fa5]+/g, '');
-            const needle = normalizeModel(wantSet);
-            const exactIdx = opts.findIndex((t) => normalizeModel(t) === needle);
-            const partialMatches = exactIdx >= 0 ? [] : opts
-                .map((model, index) => ({ model, index }))
-                .filter((item) => normalizeModel(item.model).includes(needle));
-            if (exactIdx < 0 && partialMatches.length > 1) {
-                try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
-                throw new ArgumentError('set', `Model "${wantSet}" is ambiguous: ${partialMatches.map(item => item.model).join(', ')}`);
-            }
-            const idx = exactIdx >= 0 ? exactIdx : partialMatches[0]?.index ?? -1;
-            if (idx < 0) {
-                try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
-                throw new ArgumentError('set', `No model matched "${wantSet}". Available: ${opts.join(', ')}`);
-            }
-            const clickRes = await page.evaluate(`(() => {
-        ${IS_VISIBLE_JS}
-        const popovers = Array.from(document.querySelectorAll('[class*="popover"i], [class*="dropdown"i], [role="menu"], [role="listbox"]')).filter(isVisible);
-        const pop = popovers[popovers.length - 1];
-        if (!pop) return { ok: false };
-        const items = Array.from(pop.querySelectorAll('div, li, button, [role="option"], [role="menuitem"]'))
-          .filter(isVisible)
-          .filter((el) => { const t = (el.innerText || '').trim(); return t && t.length < 80 && (/K\\d|Kimi|Pro\\b|Auto|思考/.test(t)); });
-        const target = items[${idx}];
-        if (!target) return { ok: false };
-        target.click();
-        return { ok: true, clicked: (target.innerText || '').trim() };
-            })()`);
-            if (!clickRes?.ok) throw new CommandExecutionError('Failed to click model option', '');
-            await page.wait(0.5);
-            const verified = await page.evaluate(`(() => {
-      ${IS_VISIBLE_JS}
-      const svgs = Array.from(document.querySelectorAll('svg[name="Down_b"]')).filter(isVisible);
-      for (const svg of svgs) {
-        let p = svg.parentElement;
-        for (let i = 0; i < 4 && p; i++) {
-          const spans = p.querySelectorAll('span');
-          for (const s of spans) {
-            const t = (s.textContent || '').trim();
-            if (/^K\\d|^Kimi |^Pro\\b|^Auto/.test(t)) return t;
-          }
-          p = p.parentElement;
-        }
-      }
-      return '';
-    })()`);
-            if (normalizeModel(verified) !== normalizeModel(clickRes.clicked)) {
-                throw new CommandExecutionError(
-                    `Kimi model switch did not verify the requested model: requested "${wantSet}", current "${verified || 'not visible'}"`,
-                    'Open the Kimi model menu and verify the requested model is selectable, then retry.',
-                );
-            }
-            return [{ Index: 1, Model: clickRes.clicked, Active: 'switched' }];
-        }
-
-        try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
-        if (!opts.length) {
-            throw new EmptyResultError('kimi model', 'Model dropdown opened but no options detected.');
-        }
-        return opts.map((m, i) => ({ Index: i + 1, Model: m, Active: m === cur ? 'yes' : '' }));
-    },
-});

package/clis/kimi/usage.js

@@ -1,144 +0,0 @@
-// Kimi Code console usage summary.
-// Reads the four dashboard cards from https://www.kimi.com/code/console
-
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import {
-    CommandExecutionError,
-} from '@agentrhq/webcmd/errors';
-
-const KIMI_DOMAIN = 'kimi.com';
-const KIMI_URL = 'https://www.kimi.com/';
-const CONSOLE_URL = `${KIMI_URL}code/console`;
-
-const IS_VISIBLE_JS = `
-  const isVisible = (el) => {
-    if (!el) return false;
-    const r = el.getBoundingClientRect();
-    if (r.width < 1 || r.height < 1) return false;
-    const cs = getComputedStyle(el);
-    if (cs.visibility === 'hidden' || cs.display === 'none' || cs.opacity === '0') return false;
-    return true;
-  };
-`;
-
-const CATEGORIES = ['本周用量', '频限明细', '我的权益', '模型权限'];
-
-function parsePct(value) {
-    const m = String(value || '').match(/(\d+(?:\.\d+)?)\s*%/);
-    return m ? Number(m[1]) : null;
-}
-
-function requireCard(cards, name) {
-    const values = cards[name];
-    if (!Array.isArray(values) || values.length === 0) {
-        throw new CommandExecutionError(`kimi usage returned malformed payload: missing "${name}" card`);
-    }
-    const normalized = values.map((value) => String(value || '').trim()).filter(Boolean);
-    if (normalized.length === 0) {
-        throw new CommandExecutionError(`kimi usage returned malformed payload: missing "${name}" card`);
-    }
-    return normalized;
-}
-
-function requirePct(values, name) {
-    const pct = parsePct(values[0]);
-    if (!Number.isFinite(pct)) {
-        throw new CommandExecutionError(`kimi usage returned malformed payload: "${name}" card is missing a percentage`);
-    }
-    return pct;
-}
-
-cli({
-    site: 'kimi',
-    name: 'usage',
-    access: 'read',
-    description: 'Read Kimi Code console usage cards: weekly quota, rate limit, membership, and model permission.',
-    domain: KIMI_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: true,
-    args: [],
-    columns: [
-        'weeklyUsagePct',
-        'weeklyResetIn',
-        'rateLimitPct',
-        'rateLimitResetIn',
-        'membershipName',
-        'membershipTier',
-        'modelPermission',
-        'modelCost',
-    ],
-    func: async (page) => {
-        await page.goto(CONSOLE_URL);
-        await page.wait(3);
-
-        const cards = await page.evaluate(`(() => {
-            ${IS_VISIBLE_JS}
-
-            const getDirectText = (el) => {
-                let text = '';
-                for (const node of el.childNodes) {
-                    if (node.nodeType === Node.TEXT_NODE) text += node.textContent;
-                }
-                return text.trim();
-            };
-
-            const cards = {};
-            const section = document.querySelector('section');
-            if (!section) return cards;
-
-            // The first child of the first <section> holds the 4 dashboard cards.
-            const cardContainer = section.children[0];
-            if (!cardContainer) return cards;
-
-            const cardDivs = Array.from(cardContainer.children).filter(isVisible).slice(0, 4);
-            for (const card of cardDivs) {
-                const header = card.children[0];
-                const body = card.children[1];
-                if (!header || !body) continue;
-
-                const categoryEl = header.querySelector('p');
-                const category = categoryEl ? getDirectText(categoryEl) : '';
-                if (!category || !${JSON.stringify(CATEGORIES)}.includes(category)) continue;
-
-                const values = [...new Set(
-                    Array.from(body.querySelectorAll('span, p, div'))
-                        .filter(isVisible)
-                        .map(getDirectText)
-                        .filter((t) => t)
-                )];
-
-                if (values.length > 0) {
-                    cards[category] = values.slice(0, 3);
-                }
-            }
-            return cards;
-        })()`);
-
-        if (!cards || typeof cards !== 'object' || Array.isArray(cards)) {
-            throw new CommandExecutionError('kimi usage returned malformed payload: usage cards must be an object');
-        }
-        if (Object.keys(cards).length === 0) {
-            throw new CommandExecutionError('kimi usage returned malformed payload: no usage cards found on the console page');
-        }
-
-        const weekly = requireCard(cards, '本周用量');
-        const rate = requireCard(cards, '频限明细');
-        const member = requireCard(cards, '我的权益');
-        const model = requireCard(cards, '模型权限');
-        const weeklyUsagePct = requirePct(weekly, '本周用量');
-        const rateLimitPct = requirePct(rate, '频限明细');
-
-        return [{
-            weeklyUsagePct,
-            weeklyResetIn: weekly.find((t) => /重置/.test(t)) || null,
-            rateLimitPct,
-            rateLimitResetIn: rate.find((t) => /重置/.test(t)) || null,
-            membershipName: member[0] || null,
-            membershipTier: member.find((t) => t !== member[0]) || null,
-            modelPermission: model[0] || null,
-            modelCost: model.find((t) => t !== model[0]) || null,
-        }];
-    },
-});

package/clis/linux-do/auth.js

@@ -1,55 +0,0 @@
-import { AuthRequiredError, CommandExecutionError } from '@agentrhq/webcmd/errors';
-import { registerSiteAuthCommands } from '../_shared/site-auth.js';
-
-async function hasLinuxDoSessionCookie(page) {
-  const cookies = await page.getCookies({ url: 'https://linux.do' });
-  return cookies.some(c => c.name === '_t' && c.value);
-}
-
-async function verifyLinuxDoIdentity(page) {
-  if (!await hasLinuxDoSessionCookie(page)) {
-    throw new AuthRequiredError('linux.do', 'Linux.do _t cookie missing — anonymous');
-  }
-  await page.goto('https://linux.do/');
-  await page.wait(2);
-  const probe = await page.evaluate(`(async () => {
-    try {
-      const u = document.querySelector('meta[name="current-user-username"]')?.getAttribute('content') || '';
-      if (!u) return { kind: 'auth', detail: 'Linux.do meta[current-user-username] missing — anonymous' };
-      const r = await fetch('/u/' + encodeURIComponent(u) + '.json', {
-        credentials: 'include',
-        headers: { Accept: 'application/json' },
-      });
-      if (r.status === 401 || r.status === 403) {
-        return { kind: 'auth', detail: 'Linux.do /u/<self>.json HTTP ' + r.status };
-      }
-      if (!r.ok) return { kind: 'http', httpStatus: r.status };
-      const d = await r.json();
-      const user = d?.user;
-      if (!user || !user.id) return { kind: 'auth', detail: 'Linux.do /u/<self>.json missing user.id' };
-      return { ok: true, user_id: String(user.id), username: String(user.username || u), name: String(user.name || '') };
-    } catch (e) {
-      return { kind: 'exception', detail: String(e && e.message || e) };
-    }
-  })()`);
-  if (probe?.kind === 'auth') throw new AuthRequiredError('linux.do', probe.detail);
-  if (probe?.kind === 'http') throw new CommandExecutionError(`HTTP ${probe.httpStatus} from Linux.do /u/<self>.json`);
-  if (probe?.kind === 'exception') throw new CommandExecutionError(`Linux.do whoami failed: ${probe.detail}`);
-  if (!probe?.ok) throw new CommandExecutionError(`Unexpected Linux.do probe: ${JSON.stringify(probe)}`);
-  return { user_id: probe.user_id, username: probe.username, name: probe.name };
-}
-
-registerSiteAuthCommands({
-  site: 'linux-do',
-  domain: 'linux.do',
-  loginUrl: 'https://linux.do/login',
-  columns: ['user_id', 'username', 'name'],
-  quickCheck: hasLinuxDoSessionCookie,
-  verify: verifyLinuxDoIdentity,
-  poll: async (page) => {
-    if (!await hasLinuxDoSessionCookie(page)) {
-      throw new AuthRequiredError('linux.do', 'Waiting for Linux.do _t cookie');
-    }
-    return verifyLinuxDoIdentity(page);
-  },
-});