@agentrhq/webcmd 0.1.1 → 0.2.0

package/clis/quark/save.js

@@ -1,81 +0,0 @@
-import { ArgumentError, CommandExecutionError } from '@agentrhq/webcmd/errors';
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { SHARE_API, extractPwdId, apiPost, getToken, pollTask, findFolder, } from './utils.js';
-async function saveShare(page, pwdId, stoken, fidList, targetFid, saveAll) {
-    const data = await apiPost(page, `${SHARE_API}/save?pr=ucpro&fr=pc`, {
-        pwd_id: pwdId,
-        stoken,
-        pdir_fid: '0',
-        to_pdir_fid: targetFid,
-        fid_list: fidList,
-        pdir_save_all: saveAll,
-        scene: 'link',
-    });
-    return data.task_id;
-}
-cli({
-    site: 'quark',
-    name: 'save',
-    access: 'write',
-    description: 'Save shared files to your Quark Drive',
-    domain: 'pan.quark.cn',
-    strategy: Strategy.COOKIE,
-    defaultFormat: 'json',
-    args: [
-        { name: 'url', required: true, positional: true, help: 'Quark share URL or pwd_id' },
-        { name: 'to', default: '', help: 'Destination folder path' },
-        { name: 'to-fid', default: '', help: 'Destination folder ID (overrides --to)' },
-        { name: 'fids', default: '', help: 'File IDs to save (comma-separated, from share-tree). Omit to save all.' },
-        { name: 'stoken', default: '', help: 'Share token (from share-tree output, required with --fids)' },
-        { name: 'passcode', default: '', help: 'Share passcode (if required)' },
-        { name: 'timeout', type: 'int', required: false, default: 120, help: 'Max seconds for the overall command (default: 120)' },
-    ],
-    func: async (page, kwargs) => {
-        const url = kwargs.url;
-        const to = kwargs.to;
-        const toFid = kwargs['to-fid'];
-        const fids = kwargs.fids;
-        const stokenArg = kwargs.stoken;
-        const passcode = kwargs.passcode;
-        if (!to && !toFid)
-            throw new ArgumentError('Either --to or --to-fid is required');
-        if (to && toFid)
-            throw new ArgumentError('Cannot use both --to and --to-fid');
-        const pwdId = extractPwdId(url);
-        const saveAll = !fids;
-        let stoken;
-        let fidList;
-        if (saveAll) {
-            stoken = stokenArg || await getToken(page, pwdId, passcode);
-            fidList = [];
-        }
-        else {
-            if (!stokenArg)
-                throw new ArgumentError('--stoken is required when using --fids');
-            stoken = stokenArg;
-            fidList = [...new Set(fids.split(',').map(id => id.trim()).filter(Boolean))];
-        }
-        const targetFid = toFid || await findFolder(page, to);
-        const taskId = await saveShare(page, pwdId, stoken, fidList, targetFid, saveAll);
-        const result = {
-            success: false,
-            task_id: taskId,
-            saved_to: to || toFid,
-            target_fid: targetFid,
-            ...(saveAll ? {} : { fids: fidList }),
-        };
-        if (taskId) {
-            const completed = await pollTask(page, taskId, (task) => {
-                result.save_count = task.save_as?.save_as_sum_num;
-            });
-            result.completed = completed;
-            result.success = completed;
-            if (!completed)
-                throw new CommandExecutionError('quark: Save task timed out');
-        }
-        else {
-            result.success = true;
-        }
-        return result;
-    },
-});

package/clis/quark/share-tree.js

@@ -1,46 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { extractPwdId, formatDate, getShareList, getToken, } from './utils.js';
-async function buildTree(page, pwdId, stoken, pdirFid, depth, maxDepth) {
-    if (depth > maxDepth)
-        return [];
-    const files = await getShareList(page, pwdId, stoken, pdirFid, { sort: 'file_type:asc,file_name:asc' });
-    const nodes = [];
-    for (const file of files) {
-        const node = {
-            fid: file.fid,
-            name: file.file_name,
-            size: file.size,
-            is_dir: file.dir,
-            created_at: formatDate(file.created_at),
-            updated_at: formatDate(file.updated_at),
-        };
-        if (file.dir && depth < maxDepth) {
-            node.children = await buildTree(page, pwdId, stoken, file.fid, depth + 1, maxDepth);
-        }
-        nodes.push(node);
-    }
-    return nodes;
-}
-cli({
-    site: 'quark',
-    name: 'share-tree',
-    access: 'read',
-    description: 'Get directory tree from Quark Drive share link as nested JSON',
-    domain: 'pan.quark.cn',
-    strategy: Strategy.COOKIE,
-    defaultFormat: 'json',
-    args: [
-        { name: 'url', required: true, positional: true, help: 'Quark share URL or pwd_id' },
-        { name: 'passcode', default: '', help: 'Share passcode (if required)' },
-        { name: 'depth', type: 'int', default: 10, help: 'Max directory depth' },
-    ],
-    func: async (page, kwargs) => {
-        const url = kwargs.url;
-        const passcode = kwargs.passcode || '';
-        const depth = kwargs.depth ?? 10;
-        const pwdId = extractPwdId(url);
-        const stoken = await getToken(page, pwdId, passcode);
-        const tree = await buildTree(page, pwdId, stoken, '0', 0, depth);
-        return { pwd_id: pwdId, stoken, tree };
-    },
-});

package/clis/quark/utils.js

@@ -1,146 +0,0 @@
-import { ArgumentError, AuthRequiredError, CommandExecutionError, getErrorMessage } from '@agentrhq/webcmd/errors';
-export const SHARE_API = 'https://drive-h.quark.cn/1/clouddrive/share/sharepage';
-export const DRIVE_API = 'https://drive-pc.quark.cn/1/clouddrive/file';
-export const TASK_API = 'https://drive-pc.quark.cn/1/clouddrive/task';
-const QUARK_DOMAIN = 'pan.quark.cn';
-const AUTH_HINT = 'Quark Drive requires a logged-in browser session';
-function isAuthFailure(message, status) {
-    if (status === 401 || status === 403)
-        return true;
-    return /not logged in|login required|please log in|authentication required|unauthorized|forbidden|未登录|请先登录|需要登录|登录/.test(message.toLowerCase());
-}
-function getErrorStatus(error) {
-    if (!error || typeof error !== 'object' || !('status' in error))
-        return undefined;
-    const status = error.status;
-    return typeof status === 'number' ? status : undefined;
-}
-function unwrapApiData(resp, action) {
-    if (resp.status === 200)
-        return resp.data;
-    if (isAuthFailure(resp.message, resp.status)) {
-        throw new AuthRequiredError(QUARK_DOMAIN, AUTH_HINT);
-    }
-    throw new CommandExecutionError(`quark: ${action}: ${resp.message}`);
-}
-export function extractPwdId(url) {
-    const m = url.match(/\/s\/([a-zA-Z0-9]+)/);
-    if (m)
-        return m[1];
-    if (/^[a-zA-Z0-9]+$/.test(url))
-        return url;
-    throw new ArgumentError(`Invalid Quark share URL: ${url}`);
-}
-export async function fetchJson(page, url, options) {
-    const method = options?.method || 'GET';
-    const body = options?.body ? JSON.stringify(options.body) : undefined;
-    const js = `fetch(${JSON.stringify(url)}, {
-    method: ${JSON.stringify(method)},
-    headers: { 'Content-Type': 'application/json' },
-    credentials: 'include',
-    ${body ? `body: ${JSON.stringify(body)},` : ''}
-  }).then(async r => {
-    const ct = r.headers.get('content-type') || '';
-    if (!ct.includes('json')) {
-      const text = await r.text().catch(() => '');
-      throw Object.assign(new Error('Non-JSON response: ' + text.slice(0, 200)), { status: r.status });
-    }
-    return r.json();
-  })`;
-    try {
-        return await page.evaluate(js);
-    }
-    catch (error) {
-        if (isAuthFailure(getErrorMessage(error), getErrorStatus(error))) {
-            throw new AuthRequiredError(QUARK_DOMAIN, AUTH_HINT);
-        }
-        throw error;
-    }
-}
-export async function apiGet(page, url) {
-    const resp = await fetchJson(page, url);
-    return unwrapApiData(resp, 'API error');
-}
-export async function apiPost(page, url, body) {
-    const resp = await fetchJson(page, url, { method: 'POST', body });
-    return unwrapApiData(resp, 'API error');
-}
-export async function getToken(page, pwdId, passcode = '') {
-    const data = await fetchJson(page, `${SHARE_API}/token?pr=ucpro&fr=pc`, {
-        method: 'POST',
-        body: { pwd_id: pwdId, passcode, support_visit_limit_private_share: true },
-    });
-    return unwrapApiData(data, 'Failed to get token').stoken;
-}
-export async function getShareList(page, pwdId, stoken, pdirFid = '0', options) {
-    const allFiles = [];
-    let pageNum = 1;
-    let total = 0;
-    do {
-        const sortParam = options?.sort ? `&_sort=${options.sort}` : '';
-        const url = `${SHARE_API}/detail?pr=ucpro&fr=pc&ver=2&pwd_id=${pwdId}&stoken=${encodeURIComponent(stoken)}&pdir_fid=${pdirFid}&force=0&_page=${pageNum}&_size=200&_fetch_total=1${sortParam}`;
-        const data = await fetchJson(page, url);
-        const files = unwrapApiData(data, 'Failed to get share list')?.list || [];
-        allFiles.push(...files);
-        total = data.metadata?._total || 0;
-        pageNum++;
-    } while (allFiles.length < total);
-    return allFiles;
-}
-export async function listMyDrive(page, pdirFid) {
-    const allFiles = [];
-    let pageNum = 1;
-    let total = 0;
-    do {
-        const url = `${DRIVE_API}/sort?pr=ucpro&fr=pc&pdir_fid=${pdirFid}&_page=${pageNum}&_size=200&_fetch_total=1&_sort=file_type:asc,file_name:asc`;
-        const data = await fetchJson(page, url);
-        const files = unwrapApiData(data, 'Failed to list drive')?.list || [];
-        allFiles.push(...files);
-        total = data.metadata?._total || 0;
-        pageNum++;
-    } while (allFiles.length < total);
-    return allFiles;
-}
-export async function findFolder(page, path) {
-    const parts = path.split('/').filter(Boolean);
-    let currentFid = '0';
-    for (const part of parts) {
-        const files = await listMyDrive(page, currentFid);
-        const existing = files.find(f => f.dir && f.file_name === part);
-        if (existing) {
-            currentFid = existing.fid;
-        }
-        else {
-            throw new CommandExecutionError(`quark: Folder "${part}" not found in "${path}"`);
-        }
-    }
-    return currentFid;
-}
-export function formatDate(ts) {
-    if (!ts)
-        return '';
-    const d = new Date(ts);
-    return d.toISOString().replace('T', ' ').slice(0, 19);
-}
-export function formatSize(bytes) {
-    if (bytes <= 0)
-        return '0 B';
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(1024));
-    return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
-}
-export async function getTaskStatus(page, taskId) {
-    const url = `${TASK_API}?pr=ucpro&fr=pc&task_id=${taskId}&retry_index=0`;
-    return apiGet(page, url);
-}
-export async function pollTask(page, taskId, onDone, maxAttempts = 30, intervalMs = 500) {
-    for (let i = 0; i < maxAttempts; i++) {
-        await new Promise(r => setTimeout(r, intervalMs));
-        const task = await getTaskStatus(page, taskId);
-        if (task?.status === 2) {
-            onDone?.(task);
-            return true;
-        }
-    }
-    return false;
-}

package/clis/quark/utils.test.js

@@ -1,58 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, CommandExecutionError } from '@agentrhq/webcmd/errors';
-import { apiGet, apiPost, extractPwdId, getShareList, getToken } from './utils.js';
-function makePage(evaluateImpl) {
-    return {
-        evaluate: vi.fn(evaluateImpl),
-    };
-}
-describe('quark utils', () => {
-    it('extractPwdId accepts share URLs and raw ids', () => {
-        expect(extractPwdId('https://pan.quark.cn/s/abc123')).toBe('abc123');
-        expect(extractPwdId('abc123')).toBe('abc123');
-    });
-    it('maps JSON auth failures to AuthRequiredError', async () => {
-        const page = makePage(async () => ({
-            status: 401,
-            code: 401,
-            message: '未登录',
-            data: null,
-        }));
-        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('maps non-JSON auth pages to AuthRequiredError', async () => {
-        const page = makePage(async () => {
-            const error = Object.assign(new Error('Non-JSON response: <html><title>登录</title></html>'), { status: 401 });
-            throw error;
-        });
-        await expect(apiPost(page, 'https://drive-pc.quark.cn/test', {})).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('keeps generic API failures as CommandExecutionError', async () => {
-        const page = makePage(async () => ({
-            status: 500,
-            code: 500,
-            message: 'server busy',
-            data: null,
-        }));
-        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('unwraps successful token responses', async () => {
-        const page = makePage(async () => ({
-            status: 200,
-            code: 0,
-            message: 'ok',
-            data: { stoken: 'token123' },
-        }));
-        await expect(getToken(page, 'abc123')).resolves.toBe('token123');
-    });
-    it('maps share-tree detail auth failures to AuthRequiredError', async () => {
-        const page = makePage(async () => ({
-            status: 401,
-            code: 401,
-            message: '请先登录',
-            data: null,
-            metadata: { _total: 0 },
-        }));
-        await expect(getShareList(page, 'abc123', 'token123')).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-});

package/clis/qwen/ask.js

@@ -1,104 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { ArgumentError, CommandExecutionError, TimeoutError } from '@agentrhq/webcmd/errors';
-import {
-    QIANWEN_DOMAIN,
-    QIANWEN_URL,
-    authRequired,
-    bubbleHtmlToMarkdown,
-    dismissLoginModal,
-    ensureOnQianwen,
-    getMessageBubbles,
-    hasLoginGate,
-    normalizeBooleanFlag,
-    sendMessage,
-    setFeatureToggle,
-    startNewChat,
-    waitForAnswer,
-} from './utils.js';
-
-cli({
-    site: 'qwen',
-    name: 'ask',
-    access: 'write',
-    description: 'Send a prompt to Qianwen and return the assistant reply',
-    domain: QIANWEN_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    defaultFormat: 'plain',
-    args: [
-        { name: 'prompt', required: true, positional: true, help: 'Prompt to send to Qianwen' },
-        { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for the response' },
-        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
-        { name: 'think', type: 'boolean', default: false, help: 'Enable 深度思考 (DeepThink)' },
-        { name: 'research', type: 'boolean', default: false, help: 'Enable 深度研究 (DeepResearch)' },
-        { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant reply as markdown' },
-    ],
-    columns: ['Role', 'Text'],
-    func: async (page, kwargs) => {
-        const prompt = String(kwargs.prompt || '').trim();
-        if (!prompt) throw new ArgumentError('prompt is required');
-        const timeout = Number(kwargs.timeout ?? 120);
-        if (!Number.isInteger(timeout) || timeout <= 0) {
-            throw new ArgumentError('timeout must be a positive integer');
-        }
-        const startFresh = normalizeBooleanFlag(kwargs.new, false);
-        const useThink = normalizeBooleanFlag(kwargs.think, false);
-        const useResearch = normalizeBooleanFlag(kwargs.research, false);
-        const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
-
-        await ensureOnQianwen(page);
-        await dismissLoginModal(page);
-
-        if (startFresh) {
-            await startNewChat(page);
-            await dismissLoginModal(page);
-        }
-
-        if (useThink) await setFeatureToggle(page, 'think', true);
-        if (useResearch) await setFeatureToggle(page, 'research', true);
-
-        // Anchor on the visible transcript BEFORE sending so waitForAnswer can
-        // bind the reply to the newly sent prompt instead of an older answer.
-        const baselineAnchor = await getBaselineChatAnchor(page);
-
-        const send = await sendMessage(page, prompt);
-        if (!send?.ok) {
-            if (await hasLoginGate(page)) throw authRequired();
-            throw new CommandExecutionError(send?.reason || 'Failed to send Qianwen prompt');
-        }
-
-        const result = await waitForAnswer(page, prompt, timeout, baselineAnchor);
-        if (result.status === 'auth_required') throw authRequired();
-        if (result.status === 'timeout') {
-            throw new TimeoutError('qianwen ask', timeout, 'No Qianwen reply observed before timeout. Retry with --timeout increased.');
-        }
-        const assistant = result.assistant;
-        if (!assistant) {
-            throw new CommandExecutionError('No assistant reply found in Qianwen chat.');
-        }
-        const answer = wantMarkdown && assistant.html
-            ? (bubbleHtmlToMarkdown(assistant.html) || assistant.text)
-            : assistant.text;
-        return [
-            { Role: 'User', Text: prompt },
-            { Role: 'Assistant', Text: answer },
-        ];
-    },
-});
-
-async function getBaselineChatAnchor(page) {
-    const bubbles = await getMessageBubbles(page);
-    const lastBubbleId = bubbles.length ? bubbles[bubbles.length - 1].id : '';
-    let lastAssistantId = '';
-    for (let i = bubbles.length - 1; i >= 0; i -= 1) {
-        if (bubbles[i].role === 'Assistant') {
-            lastAssistantId = bubbles[i].id;
-            break;
-        }
-    }
-    return { lastBubbleId, lastAssistantId };
-}
-
-export const __test__ = { getBaselineChatAnchor };

package/clis/qwen/ask.test.js

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { __test__ } from './ask.js';
-
-describe('qwen ask helpers', () => {
-    describe('getBaselineChatAnchor', () => {
-        // getMessageBubbles drives a page.evaluate that returns the raw bubble
-        // array; in tests we route page.evaluate straight to an in-memory array.
-        const fakePage = (bubbles) => ({ evaluate: () => Promise.resolve(bubbles) });
-
-        it('returns the last visible bubble and most recent Assistant bubble', async () => {
-            const bubbles = [
-                { id: 'a1', role: 'Assistant', text: 'first answer', html: '' },
-                { id: 'u1', role: 'User', text: 'follow-up', html: '' },
-                { id: 'a2', role: 'Assistant', text: 'second answer', html: '' },
-                { id: 'u2', role: 'User', text: 'newest user turn', html: '' },
-            ];
-            expect(await __test__.getBaselineChatAnchor(fakePage(bubbles))).toEqual({
-                lastBubbleId: 'u2',
-                lastAssistantId: 'a2',
-            });
-        });
-
-        it('returns empty assistant id when no Assistant bubble exists yet (fresh chat)', async () => {
-            expect(await __test__.getBaselineChatAnchor(fakePage([]))).toEqual({
-                lastBubbleId: '',
-                lastAssistantId: '',
-            });
-            expect(await __test__.getBaselineChatAnchor(fakePage([
-                { id: 'u1', role: 'User', text: 'hello', html: '' },
-            ]))).toEqual({
-                lastBubbleId: 'u1',
-                lastAssistantId: '',
-            });
-        });
-    });
-});

package/clis/qwen/auth.js

@@ -1,56 +0,0 @@
-import { AuthRequiredError, CommandExecutionError } from '@agentrhq/webcmd/errors';
-import { registerSiteAuthCommands } from '../_shared/site-auth.js';
-
-async function hasQwenSessionCookie(page) {
-  const cookies = await page.getCookies({ url: 'https://chat.qwen.ai' });
-  return cookies.some(c => c.name === 'token' && c.value);
-}
-
-async function verifyQwenIdentity(page) {
-  // Source the token via CDP getCookies (works even if `token` is httpOnly,
-  // which document.cookie cannot read).
-  const cookies = await page.getCookies({ url: 'https://chat.qwen.ai' });
-  const token = cookies.find(c => c.name === 'token')?.value || '';
-  if (!token) {
-    throw new AuthRequiredError('qwen.ai', 'Qwen token cookie missing');
-  }
-  await page.goto('https://chat.qwen.ai/');
-  await page.wait(2);
-  const result = await page.evaluate(`(async () => {
-    try {
-      const token = ${JSON.stringify(token)};
-      const res = await fetch('/api/v1/auths/', { credentials: 'include', headers: { 'Authorization': 'Bearer ' + token, 'Accept': 'application/json' } });
-      if (res.status === 401 || res.status === 403) {
-        return { kind: 'auth', detail: 'Qwen /api/v1/auths/ HTTP ' + res.status };
-      }
-      if (!res.ok) return { kind: 'http', httpStatus: res.status };
-      const d = await res.json();
-      if (!d || !d.id) {
-        return { kind: 'auth', detail: 'Qwen /api/v1/auths/ returned no user id' };
-      }
-      return { ok: true, user_id: String(d.id), name: String(d.name || '') };
-    } catch (e) {
-      return { kind: 'exception', detail: String(e && e.message || e) };
-    }
-  })()`);
-  if (result?.kind === 'auth') throw new AuthRequiredError('qwen.ai', result.detail);
-  if (result?.kind === 'http') throw new CommandExecutionError(`HTTP ${result.httpStatus} from /api/v1/auths/`);
-  if (result?.kind === 'exception') throw new CommandExecutionError(`Qwen whoami failed: ${result.detail}`);
-  if (!result?.ok) throw new CommandExecutionError(`Unexpected Qwen probe: ${JSON.stringify(result)}`);
-  return { user_id: result.user_id, name: result.name };
-}
-
-registerSiteAuthCommands({
-  site: 'qwen',
-  domain: 'qwen.ai',
-  loginUrl: 'https://chat.qwen.ai/auth?action=login',
-  columns: ['user_id', 'name'],
-  quickCheck: hasQwenSessionCookie,
-  verify: verifyQwenIdentity,
-  poll: async (page) => {
-    if (!await hasQwenSessionCookie(page)) {
-      throw new AuthRequiredError('qwen.ai', 'Waiting for Qwen token cookie');
-    }
-    return verifyQwenIdentity(page);
-  },
-});

package/clis/qwen/detail.js

@@ -1,62 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { EmptyResultError } from '@agentrhq/webcmd/errors';
-import {
-    QIANWEN_DOMAIN,
-    bubbleHtmlToMarkdown,
-    dismissLoginModal,
-    getMessageBubbles,
-    normalizeBooleanFlag,
-    parseQianwenSessionId,
-} from './utils.js';
-
-cli({
-    site: 'qwen',
-    name: 'detail',
-    access: 'read',
-    description: 'Open a Qianwen conversation by ID and read its messages',
-    domain: QIANWEN_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    navigateBefore: false,
-    siteSession: 'persistent',
-    args: [
-        { name: 'id', positional: true, required: true, help: 'Session ID (32-char hex) or full https://www.qianwen.com/chat/<id> URL' },
-        { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant replies as markdown' },
-    ],
-    columns: ['Role', 'Text'],
-    func: async (page, kwargs) => {
-        const sessionId = parseQianwenSessionId(kwargs.id);
-        const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
-
-        await page.goto(`https://www.qianwen.com/chat/${sessionId}`);
-        await page.wait(2);
-        await dismissLoginModal(page);
-
-        // Poll for the conversation transcript to load. Qianwen renders the chat
-        // page shell before fetching message history, so a fixed wait can race the
-        // initial empty render. Cap at ~20s to surface real "no data" cases without
-        // hanging on broken IDs.
-        let bubbles = [];
-        const POLL_DEADLINE_MS = 20_000;
-        const POLL_INTERVAL_S = 1;
-        const startedAt = Date.now();
-        while (Date.now() - startedAt < POLL_DEADLINE_MS) {
-            bubbles = await getMessageBubbles(page);
-            if (bubbles.length > 0) break;
-            await page.wait(POLL_INTERVAL_S);
-        }
-
-        if (!bubbles.length) {
-            throw new EmptyResultError(
-                'qwen detail',
-                `No visible messages found for conversation ${sessionId}. Verify the ID is correct and that the session belongs to the current device's b-user-id (or that you are logged in for cross-device sync).`,
-            );
-        }
-        return bubbles.map((b) => ({
-            Role: b.role,
-            Text: wantMarkdown && b.role === 'Assistant' && b.html
-                ? (bubbleHtmlToMarkdown(b.html) || b.text)
-                : b.text,
-        }));
-    },
-});

package/clis/qwen/history.js

@@ -1,61 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
-import {
-    QIANWEN_DOMAIN,
-    authRequired,
-    dismissLoginModal,
-    ensureOnQianwen,
-    getSessionListFromApi,
-} from './utils.js';
-
-function formatDate(ms) {
-    if (!ms) return '';
-    const d = new Date(ms);
-    if (Number.isNaN(d.getTime())) return '';
-    const pad = (n) => String(n).padStart(2, '0');
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
-}
-
-cli({
-    site: 'qwen',
-    name: 'history',
-    access: 'read',
-    description: 'List recent Qianwen conversations (requires login)',
-    domain: QIANWEN_DOMAIN,
-    strategy: Strategy.COOKIE,
-    browser: true,
-    siteSession: 'persistent',
-    navigateBefore: false,
-    args: [
-        { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show (default 20, max 100)' },
-    ],
-    columns: ['Index', 'Title', 'Updated', 'Url'],
-    func: async (page, kwargs) => {
-        const limit = Number(kwargs.limit ?? 20);
-        if (!Number.isInteger(limit) || limit <= 0) {
-            throw new ArgumentError('limit must be a positive integer');
-        }
-        if (limit > 100) {
-            throw new ArgumentError('limit must be <= 100');
-        }
-        await ensureOnQianwen(page);
-        await dismissLoginModal(page);
-        await page.wait(1);
-        const result = await getSessionListFromApi(page, limit);
-        if (!result.ok) {
-            if (result.status === 401 || result.status === 403) throw authRequired();
-            if (!result.sessions.length) {
-                throw new CommandExecutionError(`Qianwen history API failed (status=${result.status}) ${result.error || ''}`.trim());
-            }
-        }
-        if (!result.sessions.length) {
-            throw new EmptyResultError('qwen history', 'No Qianwen conversations found.');
-        }
-        return result.sessions.slice(0, limit).map((s, i) => ({
-            Index: i + 1,
-            Title: s.title || '(untitled)',
-            Updated: formatDate(s.updated_at),
-            Url: `https://www.qianwen.com/chat/${s.id}`,
-        }));
-    },
-});