@jackwener/opencli 1.7.11 → 1.7.13

package/clis/qwen/ask.js

@@ -0,0 +1,85 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, TimeoutError } from '@jackwener/opencli/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,
+    browserSession: { reuse: 'site' },
+    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);
+
+        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);
+        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 },
+        ];
+    },
+});

package/clis/qwen/detail.js

@@ -0,0 +1,62 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/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,
+    browserSession: { reuse: 'site' },
+    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

@@ -0,0 +1,61 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/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,
+    browserSession: { reuse: 'site' },
+    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}`,
+        }));
+    },
+});

package/clis/qwen/image.js

@@ -0,0 +1,179 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { saveBase64ToFile } from '@jackwener/opencli/utils';
+import { ArgumentError, CommandExecutionError, EmptyResultError, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    QIANWEN_DOMAIN,
+    authRequired,
+    dismissLoginModal,
+    ensureOnQianwen,
+    getMessageBubbles,
+    hasLoginGate,
+    normalizeBooleanFlag,
+    sendMessage,
+    setFeatureToggle,
+    startNewChat,
+} from './utils.js';
+
+function displayPath(filePath) {
+    const home = os.homedir();
+    return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+
+function extFromMime(mime) {
+    if (!mime) return '.jpg';
+    if (mime.includes('png')) return '.png';
+    if (mime.includes('webp')) return '.webp';
+    if (mime.includes('gif')) return '.gif';
+    return '.jpg';
+}
+
+async function collectImageUrls(page, sinceAssistantId) {
+    return await page.evaluate(`(() => {
+    const scope = ${JSON.stringify(sinceAssistantId || '')};
+    const bubbles = Array.from(document.querySelectorAll('[data-msgid$="-answer"]'));
+    const target = scope
+      ? bubbles.find((b) => b.getAttribute('data-msgid') === scope)
+      : bubbles[bubbles.length - 1];
+    if (!target) return [];
+    const imgs = Array.from(target.querySelectorAll('img'))
+      .map((node) => node.getAttribute('src') || '')
+      .filter((src) => src
+        && !src.startsWith('data:')
+        && !/\\.(svg)$/i.test(src)
+        && !src.includes('alicdn.com/imgextra'));
+    return Array.from(new Set(imgs));
+  })()`);
+}
+
+async function waitForImageUrls(page, sinceAssistantId, timeoutSeconds) {
+    const startTime = Date.now();
+    let lastUrls = [];
+    while (Date.now() - startTime < timeoutSeconds * 1000) {
+        await page.wait(2);
+        if (await hasLoginGate(page)) return { status: 'auth_required', urls: [] };
+        const urls = await collectImageUrls(page, sinceAssistantId);
+        if (urls.length && urls.length === lastUrls.length && urls.every((u, i) => u === lastUrls[i])) {
+            return { status: 'ok', urls };
+        }
+        if (urls.length) {
+            await page.wait(2);
+            const urls2 = await collectImageUrls(page, sinceAssistantId);
+            if (urls2.length === urls.length && urls2.every((u, i) => u === urls[i])) {
+                return { status: 'ok', urls: urls2 };
+            }
+            lastUrls = urls2;
+            continue;
+        }
+        lastUrls = urls;
+    }
+    return lastUrls.length ? { status: 'partial', urls: lastUrls } : { status: 'timeout', urls: [] };
+}
+
+async function fetchImageAsset(page, url) {
+    return await page.evaluate(`(async () => {
+    try {
+      const res = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+      if (!res.ok) return { ok: false, status: res.status };
+      const mime = res.headers.get('content-type') || '';
+      const buf = await res.arrayBuffer();
+      const bytes = new Uint8Array(buf);
+      let binary = '';
+      const chunk = 0x8000;
+      for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk));
+      }
+      return { ok: true, mime, base64: btoa(binary) };
+    } catch (error) {
+      return { ok: false, status: 0, error: String(error?.message || error) };
+    }
+  })()`);
+}
+
+cli({
+    site: 'qwen',
+    name: 'image',
+    access: 'write',
+    description: 'Generate images with Qianwen (AI生图) and save them locally',
+    domain: QIANWEN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    defaultFormat: 'plain',
+    args: [
+        { name: 'prompt', required: true, positional: true, help: 'Image prompt to send' },
+        { name: 'op', default: '~/Pictures/qianwen', help: 'Output directory' },
+        { name: 'new', type: 'boolean', default: true, help: 'Start a new chat before generating (default: true)' },
+        { name: 'sd', type: 'boolean', default: false, help: 'Skip download; only show the Qianwen link' },
+        { name: 'timeout', type: 'int', default: 180, help: 'Max seconds to wait for the image response' },
+    ],
+    columns: ['Status', 'File', 'Link'],
+    func: async (page, kwargs) => {
+        const prompt = String(kwargs.prompt || '').trim();
+        if (!prompt) throw new ArgumentError('prompt is required');
+        const outputDir = String(kwargs.op || '~/Pictures/qianwen').replace(/^~\//, `${os.homedir()}/`);
+        const startFresh = normalizeBooleanFlag(kwargs.new, true);
+        const skipDownload = normalizeBooleanFlag(kwargs.sd, false);
+        const timeout = Number(kwargs.timeout ?? 180);
+        if (!Number.isInteger(timeout) || timeout <= 0) {
+            throw new ArgumentError('timeout must be a positive integer');
+        }
+
+        await ensureOnQianwen(page);
+        await dismissLoginModal(page);
+        if (startFresh) {
+            await startNewChat(page);
+            await dismissLoginModal(page);
+        }
+        await setFeatureToggle(page, 'image', true);
+        await page.wait(0.5);
+
+        const send = await sendMessage(page, prompt);
+        if (!send?.ok) {
+            if (await hasLoginGate(page)) throw authRequired();
+            throw new CommandExecutionError(send?.reason || 'Failed to send Qianwen image prompt');
+        }
+
+        // Grab the newest assistant bubble id after send by polling briefly
+        let targetId = '';
+        for (let i = 0; i < 5; i += 1) {
+            await page.wait(1);
+            const bubbles = await getMessageBubbles(page);
+            const lastAnswer = [...bubbles].reverse().find((b) => b.role === 'Assistant');
+            if (lastAnswer) { targetId = lastAnswer.id; break; }
+        }
+
+        const waitResult = await waitForImageUrls(page, targetId, timeout);
+        const link = await page.evaluate('window.location.href').catch(() => 'https://www.qianwen.com/');
+        if (waitResult.status === 'auth_required') throw authRequired();
+        if (waitResult.status === 'timeout') {
+            throw new TimeoutError('qianwen image', timeout, 'No generated images observed before timeout.');
+        }
+
+        const urls = waitResult.urls;
+        if (skipDownload) {
+            return [{ Status: '🎨 generated', File: null, Link: link }];
+        }
+
+        const stamp = Date.now();
+        const results = [];
+        for (let i = 0; i < urls.length; i += 1) {
+            const url = urls[i];
+            const asset = await fetchImageAsset(page, url);
+            if (!asset?.ok) {
+                throw new CommandExecutionError(`Failed to fetch generated Qianwen image ${i + 1}: status=${asset?.status || '?'}`);
+            }
+            const suffix = urls.length > 1 ? `_${i + 1}` : '';
+            const ext = extFromMime(asset.mime);
+            const filePath = path.join(outputDir, `qianwen_${stamp}${suffix}${ext}`);
+            await saveBase64ToFile(asset.base64, filePath);
+            results.push({ Status: '✅ saved', File: displayPath(filePath), Link: link });
+        }
+        if (!results.length) {
+            throw new EmptyResultError('qwen image', 'No generated images were available to download.');
+        }
+        return results;
+    },
+});

package/clis/qwen/new.js

@@ -0,0 +1,23 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { QIANWEN_DOMAIN, QIANWEN_URL, startNewChat, dismissLoginModal } from './utils.js';
+
+cli({
+    site: 'qwen',
+    name: 'new',
+    access: 'write',
+    description: 'Start a new conversation in Qianwen',
+    domain: QIANWEN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        await page.goto(QIANWEN_URL);
+        await page.wait(2);
+        await dismissLoginModal(page);
+        await startNewChat(page);
+        return [{ Status: 'New chat started' }];
+    },
+});

package/clis/qwen/read.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    QIANWEN_DOMAIN,
+    bubbleHtmlToMarkdown,
+    dismissLoginModal,
+    ensureOnQianwen,
+    getMessageBubbles,
+    normalizeBooleanFlag,
+} from './utils.js';
+
+cli({
+    site: 'qwen',
+    name: 'read',
+    access: 'read',
+    description: 'Read messages in the current Qianwen conversation',
+    domain: QIANWEN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant replies as markdown' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
+        await ensureOnQianwen(page);
+        await dismissLoginModal(page);
+        await page.wait(2);
+        const bubbles = await getMessageBubbles(page);
+        if (!bubbles.length) {
+            return [{ Role: 'system', Text: 'No visible messages in the current conversation.' }];
+        }
+        return bubbles.map((b) => ({
+            Role: b.role,
+            Text: wantMarkdown && b.role === 'Assistant' && b.html
+                ? (bubbleHtmlToMarkdown(b.html) || b.text)
+                : b.text,
+        }));
+    },
+});

package/clis/qwen/send.js

@@ -0,0 +1,55 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    QIANWEN_DOMAIN,
+    authRequired,
+    dismissLoginModal,
+    ensureOnQianwen,
+    hasLoginGate,
+    normalizeBooleanFlag,
+    sendMessage,
+    setFeatureToggle,
+    startNewChat,
+} from './utils.js';
+
+cli({
+    site: 'qwen',
+    name: 'send',
+    access: 'write',
+    description: 'Fire-and-forget: send a prompt to Qianwen without waiting for the reply',
+    domain: QIANWEN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'prompt', required: true, positional: true, help: 'Prompt to send to Qianwen' },
+        { 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)' },
+    ],
+    columns: ['Status', 'Prompt'],
+    func: async (page, kwargs) => {
+        const prompt = String(kwargs.prompt || '').trim();
+        if (!prompt) throw new ArgumentError('prompt is required');
+        const startFresh = normalizeBooleanFlag(kwargs.new, false);
+        const useThink = normalizeBooleanFlag(kwargs.think, false);
+        const useResearch = normalizeBooleanFlag(kwargs.research, 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);
+
+        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');
+        }
+        return [{ Status: 'sent', Prompt: prompt }];
+    },
+});

package/clis/qwen/status.js

@@ -0,0 +1,37 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { QIANWEN_DOMAIN, ensureOnQianwen, isLoggedIn, getCurrentSessionId, getModelLabel } from './utils.js';
+
+cli({
+    site: 'qwen',
+    name: 'status',
+    access: 'read',
+    description: 'Check Qianwen page availability, login state, current session and model',
+    domain: QIANWEN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [],
+    columns: ['Status', 'Login', 'Model', 'SessionId', 'Url'],
+    func: async (page) => {
+        await ensureOnQianwen(page);
+        await page.wait(2);
+        const [loggedIn, sessionId, model, url] = await Promise.all([
+            isLoggedIn(page),
+            getCurrentSessionId(page),
+            getModelLabel(page),
+            page.evaluate('window.location.href').catch(() => ''),
+        ]);
+        // Model / SessionId may be unknown when the page is loading or the user
+        // is in guest mode. Surface that as `null` (typed unknown) instead of a
+        // string sentinel like '-' — agents can branch on null cleanly, and a
+        // sentinel string would silently get treated as a real model name.
+        return [{
+            Status: 'Connected',
+            Login: loggedIn ? 'Yes' : 'No (guest mode)',
+            Model: model ? model : null,
+            SessionId: sessionId ? sessionId : null,
+            Url: typeof url === 'string' ? url : '',
+        }];
+    },
+});