@skills-store/rednote 0.1.14 → 0.1.16

package/dist/rednote/getMyProfile.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { runCli } from '../utils/browser-cli.js';
+import { resolveStatusTarget } from './status.js';
+import { createRednoteSession, disconnectRednoteSession, ensureRednoteLoggedIn } from './checkLogin.js';
+import { getProfile, selectProfileOutput, renderProfileMarkdown } from './getProfile.js';
+import { ensureJsonSavePath, renderJsonSaveSummary, resolveJsonSavePath, writeJsonFile } from './output-format.js';
+import { persistProfile } from './persistence.js';
+function printGetMyProfileHelp() {
+    process.stdout.write(`rednote get-my-profile
+
+Usage:
+  npx -y @skills-store/rednote get-my-profile [--instance NAME] [--mode profile|notes] [--max-notes N] [--format md|json] [--save PATH]
+  node --experimental-strip-types ./scripts/rednote/getMyProfile.ts --instance NAME [--mode profile|notes] [--max-notes N] [--format md|json] [--save PATH]
+  bun ./scripts/rednote/getMyProfile.ts --instance NAME [--mode profile|notes] [--max-notes N] [--format md|json] [--save PATH]
+
+Options:
+  --instance NAME   Optional. Defaults to the saved lastConnect instance
+  --mode MODE       Optional. profile | notes. Default: profile
+  --max-notes N     Optional. Max notes to fetch by scrolling. Default: 100
+  --format FORMAT   Output format: md | json. Default: md
+  --save PATH       Required when --format json is used. Saves only the selected mode data as JSON
+  -h, --help        Show this help
+`);
+}
+export function parseGetMyProfileCliArgs(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        strict: false,
+        options: {
+            instance: {
+                type: 'string'
+            },
+            format: {
+                type: 'string'
+            },
+            mode: {
+                type: 'string'
+            },
+            'max-notes': {
+                type: 'string'
+            },
+            save: {
+                type: 'string'
+            },
+            help: {
+                type: 'boolean',
+                short: 'h'
+            }
+        }
+    });
+    if (positionals.length > 0) {
+        throw new Error(`Unexpected positional arguments: ${positionals.join(' ')}`);
+    }
+    const format = values.format ?? 'md';
+    if (format !== 'md' && format !== 'json') {
+        throw new Error(`Invalid --format value: ${String(format)}`);
+    }
+    const mode = values.mode ?? 'profile';
+    if (mode !== 'profile' && mode !== 'notes') {
+        throw new Error(`Invalid --mode value: ${String(values.mode)}`);
+    }
+    const maxNotesValue = values['max-notes'] ?? '100';
+    const maxNotes = parseInt(maxNotesValue, 10);
+    if (isNaN(maxNotes) || maxNotes < 1) {
+        throw new Error(`Invalid --max-notes value: ${maxNotesValue}`);
+    }
+    return {
+        instance: values.instance,
+        format,
+        mode,
+        maxNotes,
+        savePath: values.save,
+        help: values.help
+    };
+}
+function writeMyProfileOutput(result, values) {
+    const output = selectProfileOutput(result, values.mode);
+    if (values.format === 'json') {
+        const savedPath = resolveJsonSavePath(values.savePath);
+        writeJsonFile(output, savedPath);
+        process.stdout.write(renderJsonSaveSummary(savedPath, output));
+        return;
+    }
+    process.stdout.write(renderProfileMarkdown(result, values.mode));
+}
+async function navigateToMyProfile(page) {
+    await page.goto('https://www.xiaohongshu.com/explore', {
+        waitUntil: 'domcontentloaded'
+    });
+    await page.waitForTimeout(2000);
+    const userLink = page.locator('.user.side-bar-component').first();
+    await userLink.click();
+    await page.waitForURL(/\/user\/profile\//, {
+        timeout: 10000
+    });
+    await page.waitForTimeout(1000);
+    const profileUrl = page.url();
+    const match = profileUrl.match(/\/user\/profile\/([^/?]+)/);
+    if (!match) {
+        throw new Error(`Failed to extract userId from profile URL: ${profileUrl}`);
+    }
+    const userId = match[1];
+    return {
+        userId,
+        profileUrl
+    };
+}
+export async function runGetMyProfileCommand(values = {
+    format: 'md',
+    mode: 'profile',
+    maxNotes: 100
+}) {
+    if (values.help) {
+        printGetMyProfileHelp();
+        return;
+    }
+    ensureJsonSavePath(values.format, values.savePath);
+    const target = resolveStatusTarget(values.instance);
+    const session = await createRednoteSession(target);
+    try {
+        await ensureRednoteLoggedIn(target, 'fetching my profile', session);
+        const { userId, profileUrl } = await navigateToMyProfile(session.page);
+        const result = await getProfile(session, profileUrl, userId, values.maxNotes);
+        await persistProfile({
+            instanceName: target.instanceName,
+            result
+        });
+        writeMyProfileOutput(result, values);
+    } finally{
+        await disconnectRednoteSession(session);
+    }
+}
+async function main() {
+    const values = parseGetMyProfileCliArgs(process.argv.slice(2));
+    await runGetMyProfileCommand(values);
+}
+runCli(import.meta.url, main);

package/dist/rednote/getProfile.js

@@ -3,21 +3,24 @@ import * as cheerio from 'cheerio';
 import { parseArgs } from 'node:util';
 import vm from 'node:vm';
 import { runCli } from '../utils/browser-cli.js';
+import { simulateMouseMove, simulateMouseWheel } from '../utils/mouse-helper.js';
 import { resolveStatusTarget } from './status.js';
 import { createRednoteSession, disconnectRednoteSession, ensureRednoteLoggedIn } from './checkLogin.js';
 import { ensureJsonSavePath, renderJsonSaveSummary, renderPostsMarkdown, resolveJsonSavePath, writeJsonFile } from './output-format.js';
+import { persistProfile } from './persistence.js';
 function printGetProfileHelp() {
     process.stdout.write(`rednote get-profile
 
 Usage:
-  npx -y @skills-store/rednote get-profile [--instance NAME] --id USER_ID [--mode profile|notes] [--format md|json] [--save PATH]
-  node --experimental-strip-types ./scripts/rednote/getProfile.ts --instance NAME --id USER_ID [--mode profile|notes] [--format md|json] [--save PATH]
-  bun ./scripts/rednote/getProfile.ts --instance NAME --id USER_ID [--mode profile|notes] [--format md|json] [--save PATH]
+  npx -y @skills-store/rednote get-profile [--instance NAME] --id USER_ID [--mode profile|notes] [--max-notes N] [--format md|json] [--save PATH]
+  node --experimental-strip-types ./scripts/rednote/getProfile.ts --instance NAME --id USER_ID [--mode profile|notes] [--max-notes N] [--format md|json] [--save PATH]
+  bun ./scripts/rednote/getProfile.ts --instance NAME --id USER_ID [--mode profile|notes] [--max-notes N] [--format md|json] [--save PATH]
 
 Options:
   --instance NAME   Optional. Defaults to the saved lastConnect instance
   --id USER_ID      Required. Xiaohongshu profile user id
   --mode MODE       Optional. profile | notes. Default: profile
+  --max-notes N     Optional. Max notes to fetch by scrolling. Default: 100
   --format FORMAT   Output format: md | json. Default: md
   --save PATH       Required when --format json is used. Saves only the selected mode data as JSON
   -h, --help        Show this help
@@ -41,6 +44,9 @@ export function parseGetProfileCliArgs(argv) {
             mode: {
                 type: 'string'
             },
+            'max-notes': {
+                type: 'string'
+            },
             save: {
                 type: 'string'
             },
@@ -61,11 +67,17 @@ export function parseGetProfileCliArgs(argv) {
     if (mode !== 'profile' && mode !== 'notes') {
         throw new Error(`Invalid --mode value: ${String(values.mode)}`);
     }
+    const maxNotesValue = values['max-notes'] ?? '100';
+    const maxNotes = parseInt(maxNotesValue, 10);
+    if (isNaN(maxNotes) || maxNotes < 1) {
+        throw new Error(`Invalid --max-notes value: ${maxNotesValue}`);
+    }
     return {
         instance: values.instance,
         id: values.id,
         format,
         mode,
+        maxNotes,
         savePath: values.save,
         help: values.help
     };
@@ -228,67 +240,164 @@ function renderProfileUserMarkdown(result) {
     lines.push(`- Tags: ${user.tags.length > 0 ? user.tags.map((tag)=>`#${tag}`).join(' ') : ''}`);
     return `${lines.join('\n')}\n`;
 }
-function selectProfileOutput(result, mode) {
+export function selectProfileOutput(result, mode) {
     return mode === 'notes' ? result.profile.notes : result.profile.user;
 }
-function renderProfileMarkdown(result, mode) {
+export function renderProfileMarkdown(result, mode) {
     if (mode === 'notes') {
         return renderPostsMarkdown(result.profile.notes);
     }
     return renderProfileUserMarkdown(result);
 }
-async function captureProfile(page, targetUrl) {
+const NOTES_CONTAINER_SELECTOR = '.feeds-tab-container';
+const NOTES_SCROLL_TIMEOUT_MS = 60_000;
+const NOTES_SCROLL_IDLE_LIMIT = 4;
+async function scrollNotesContainer(page, maxNotes, getNoteCount) {
+    const container = page.locator(NOTES_CONTAINER_SELECTOR).first();
+    const visible = await container.isVisible().catch(()=>false);
+    if (!visible) {
+        return;
+    }
+    await container.scrollIntoViewIfNeeded().catch(()=>{});
+    await simulateMouseMove(page, {
+        locator: container,
+        settleMs: 100
+    }).catch(()=>{});
+    const getMetrics = async ()=>await container.evaluate((element)=>{
+            const htmlElement = element;
+            const atBottom = htmlElement.scrollTop + htmlElement.clientHeight >= htmlElement.scrollHeight - 8;
+            return {
+                scrollTop: htmlElement.scrollTop,
+                scrollHeight: htmlElement.scrollHeight,
+                clientHeight: htmlElement.clientHeight,
+                atBottom
+            };
+        }).catch(()=>null);
+    const deadline = Date.now() + NOTES_SCROLL_TIMEOUT_MS;
+    let idleRounds = 0;
+    while(Date.now() < deadline){
+        if (getNoteCount() >= maxNotes) {
+            return;
+        }
+        const beforeMetrics = await getMetrics();
+        if (!beforeMetrics) {
+            return;
+        }
+        const beforeCount = getNoteCount();
+        const delta = Math.max(Math.floor(beforeMetrics.clientHeight * 0.85), 480);
+        await simulateMouseWheel(page, {
+            locator: container,
+            deltaY: delta,
+            moveBeforeScroll: false,
+            settleMs: 900
+        }).catch(()=>{});
+        const afterMetrics = await getMetrics();
+        await page.waitForTimeout(400);
+        const afterCount = getNoteCount();
+        const countChanged = afterCount > beforeCount;
+        const scrollMoved = Boolean(afterMetrics) && afterMetrics.scrollTop > beforeMetrics.scrollTop;
+        const reachedBottom = Boolean(afterMetrics?.atBottom);
+        if (countChanged || scrollMoved) {
+            idleRounds = 0;
+            continue;
+        }
+        idleRounds += 1;
+        if (reachedBottom && idleRounds >= 2 || idleRounds >= NOTES_SCROLL_IDLE_LIMIT) {
+            return;
+        }
+    }
+}
+async function captureProfile(page, targetUrl, maxNotes) {
     let userPageData = null;
-    let notes = null;
+    const notesMap = new Map();
     const handleResponse = async (response)=>{
         try {
             const url = new URL(response.url());
-            if (response.status() !== 200 || !url.href.includes('/user/profile/')) {
+            if (response.status() !== 200 || !(url.href.includes('/user/profile/') || url.href.includes('/api/sns/web/v1/user_posted'))) {
                 return;
             }
-            const html = await response.text();
-            const $ = cheerio.load(html);
-            $('script').each((_, element)=>{
-                const scriptContent = $(element).html();
-                if (!scriptContent?.includes('window.__INITIAL_STATE__')) {
-                    return;
+            if (url.href.includes('/user/profile/')) {
+                const html = await response.text();
+                const $ = cheerio.load(html);
+                $('script').each((_, element)=>{
+                    const scriptContent = $(element).html();
+                    if (!scriptContent?.includes('window.__INITIAL_STATE__')) {
+                        return;
+                    }
+                    const scriptText = scriptContent.substring(scriptContent.indexOf('=') + 1);
+                    const sandbox = {};
+                    vm.createContext(sandbox);
+                    vm.runInContext(`var info = ${scriptText}`, sandbox);
+                    userPageData = sandbox.info?.user?.userPageData ?? userPageData;
+                    const notesData = sandbox.info?.user?.notes;
+                    if (Array.isArray(notesData)) {
+                        for (const note of notesData){
+                            if (!Array.isArray(notesData)) {
+                                const noteId = note?.id ?? note?.noteId ?? note?.note_id;
+                                if (noteId && !notesMap.has(noteId)) {
+                                    notesMap.set(noteId, note);
+                                }
+                            } else {
+                                for (const _note of note){
+                                    const noteId = _note?.id ?? _note?.noteId ?? _note?.note_id;
+                                    if (noteId && !notesMap.has(noteId)) {
+                                        notesMap.set(noteId, _note);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+            if (url.href.includes('/api/sns/web/v1/user_posted')) {
+                const body = await response.json();
+                if (body.code == 0 && body.data?.notes) {
+                    if (Array.isArray(body.data?.notes)) {
+                        for (const note of body.data?.notes){
+                            const noteId = note?.id ?? note?.noteId ?? note?.note_id;
+                            if (noteId && !notesMap.has(noteId)) {
+                                notesMap.set(noteId, note);
+                            }
+                        }
+                    }
                 }
-                const scriptText = scriptContent.substring(scriptContent.indexOf('=') + 1);
-                const sandbox = {};
-                vm.createContext(sandbox);
-                vm.runInContext(`var info = ${scriptText}`, sandbox);
-                userPageData = sandbox.info?.user?.userPageData ?? userPageData;
-                notes = sandbox.info?.user?.notes ?? notes;
-            });
+            }
         } catch  {}
     };
     page.on('response', handleResponse);
     try {
-        await page.goto(targetUrl, {
-            waitUntil: 'domcontentloaded'
-        });
+        if (targetUrl !== page.url()) {
+            await page.goto(targetUrl, {
+                waitUntil: 'domcontentloaded'
+            });
+        } else {}
         const deadline = Date.now() + 15_000;
         while(Date.now() < deadline){
-            if (userPageData || notes) {
+            if (userPageData || notesMap.size > 0) {
                 break;
             }
             await page.waitForTimeout(200);
         }
-        if (!userPageData && !notes) {
+        if (!userPageData && notesMap.size === 0) {
             throw new Error(`Failed to capture profile detail: ${targetUrl}`);
         }
+        if (notesMap.size < maxNotes) {
+            await scrollNotesContainer(page, maxNotes, ()=>notesMap.size);
+        }
         return {
             userPageData,
-            notes
+            notes: [
+                ...notesMap.values()
+            ]
         };
     } finally{
         page.off('response', handleResponse);
     }
 }
-export async function getProfile(session, url, userId) {
+export async function getProfile(session, url, userId, maxNotes = 100) {
     validateProfileUrl(url);
     const page = await getOrCreateXiaohongshuPage(session);
-    const captured = await captureProfile(page, url);
+    const captured = await captureProfile(page, url, maxNotes);
     return {
         ok: true,
         profile: {
@@ -315,7 +424,8 @@ function writeProfileOutput(result, values) {
 }
 export async function runGetProfileCommand(values = {
     format: 'md',
-    mode: 'profile'
+    mode: 'profile',
+    maxNotes: 100
 }) {
     if (values.help) {
         printGetProfileHelp();
@@ -330,7 +440,11 @@ export async function runGetProfileCommand(values = {
     const session = await createRednoteSession(target);
     try {
         await ensureRednoteLoggedIn(target, 'fetching profile', session);
-        const result = await getProfile(session, buildProfileUrl(normalizedUserId), normalizedUserId);
+        const result = await getProfile(session, buildProfileUrl(normalizedUserId), normalizedUserId, values.maxNotes);
+        await persistProfile({
+            instanceName: target.instanceName,
+            result
+        });
         writeProfileOutput(result, values);
     } finally{
         await disconnectRednoteSession(session);

package/dist/rednote/index.js

@@ -11,11 +11,12 @@ Commands:
   check-login [--instance NAME]
   login [--instance NAME]
   publish [--instance NAME]
-  interact [--instance NAME] --url URL [--like] [--collect] [--comment TEXT]
+  interact [--instance NAME] [--id ID | --url URL] [--like] [--collect] [--comment TEXT]
   home [--instance NAME] [--format md|json] [--save [PATH]]
   search [--instance NAME] --keyword TEXT [--format md|json] [--save [PATH]]
   get-feed-detail [--instance NAME] --url URL [--url URL] [--comments [COUNT]] [--format md|json] [--save PATH]
   get-profile [--instance NAME] --id USER_ID [--mode profile|notes] [--format md|json] [--save PATH]
+  get-my-profile [--instance NAME] [--mode profile|notes] [--format md|json] [--save PATH]
 
 Examples:
   npx -y @skills-store/rednote browser list
@@ -25,7 +26,7 @@ Examples:
   npx -y @skills-store/rednote status --instance seller-main
   npx -y @skills-store/rednote login --instance seller-main
   npx -y @skills-store/rednote publish --instance seller-main --type video --video ./note.mp4 --title "Video title" --content "Video description"
-  npx -y @skills-store/rednote interact --instance seller-main --url "https://www.xiaohongshu.com/explore/xxx?xsec_token=yyy" --like --collect --comment "Great post"
+  npx -y @skills-store/rednote interact --instance seller-main --id NOTE_ID --like --collect --comment "Great post"
   npx -y @skills-store/rednote home --instance seller-main --format md --save
   npx -y @skills-store/rednote search --instance seller-main --keyword skincare --format json --save ./output/search.json
   npx -y @skills-store/rednote get-feed-detail --instance seller-main --url "https://www.xiaohongshu.com/explore/xxx?xsec_token=yyy" --comments 100 --format json --save ./output/feed-detail.json
@@ -127,6 +128,11 @@ export async function runRednoteCli(argv = process.argv.slice(2)) {
         await runGetProfileCommand(parseGetProfileCliArgs(commandArgv));
         return;
     }
+    if (command === 'get-my-profile') {
+        const { parseGetMyProfileCliArgs, runGetMyProfileCommand } = await import('./getMyProfile.js');
+        await runGetMyProfileCommand(parseGetMyProfileCliArgs(commandArgv));
+        return;
+    }
     throw new Error(`Unknown command: ${command}`);
 }
 async function main() {

package/dist/rednote/interact.js

@@ -4,6 +4,7 @@ import { printJson, runCli } from '../utils/browser-cli.js';
 import { resolveStatusTarget } from './status.js';
 import { createRednoteSession, disconnectRednoteSession, ensureRednoteLoggedIn } from './checkLogin.js';
 import { getFeedDetails } from './getFeedDetail.js';
+import { findPersistedPostUrlByRecordId, initializeRednoteDatabase } from './persistence.js';
 const INTERACT_CONTAINER_SELECTOR = '.interact-container';
 const LIKE_WRAPPER_SELECTOR = `${INTERACT_CONTAINER_SELECTOR} .like-wrapper`;
 const COLLECT_WRAPPER_SELECTOR = `${INTERACT_CONTAINER_SELECTOR} .collect-wrapper, ${INTERACT_CONTAINER_SELECTOR} #note-page-collect-board-guide`;
@@ -14,13 +15,14 @@ function printInteractHelp() {
     process.stdout.write(`rednote interact
 
 Usage:
-  npx -y @skills-store/rednote interact [--instance NAME] --url URL [--like] [--collect] [--comment TEXT]
-  node --experimental-strip-types ./scripts/rednote/interact.ts --instance NAME --url URL [--like] [--collect] [--comment TEXT]
-  bun ./scripts/rednote/interact.ts --instance NAME --url URL [--like] [--collect] [--comment TEXT]
+  npx -y @skills-store/rednote interact [--instance NAME] [--id ID | --url URL] [--like] [--collect] [--comment TEXT]
+  node --experimental-strip-types ./scripts/rednote/interact.ts [--instance NAME] [--id ID | --url URL] [--like] [--collect] [--comment TEXT]
+  bun ./scripts/rednote/interact.ts [--instance NAME] [--id ID | --url URL] [--like] [--collect] [--comment TEXT]
 
 Options:
   --instance NAME   Optional. Defaults to the saved lastConnect instance
-  --url URL         Required. Xiaohongshu explore url
+  --id ID           Optional. Database record id from home/search output
+  --url URL         Optional. Xiaohongshu explore url
   --like            Optional. Perform like
   --collect         Optional. Perform collect
   --comment TEXT    Optional. Post comment content
@@ -36,6 +38,9 @@ export function parseInteractCliArgs(argv) {
             instance: {
                 type: 'string'
             },
+            id: {
+                type: 'string'
+            },
             url: {
                 type: 'string'
             },
@@ -59,6 +64,7 @@ export function parseInteractCliArgs(argv) {
     }
     return {
         instance: values.instance,
+        id: values.id,
         url: values.url,
         like: values.like,
         collect: values.collect,
@@ -253,8 +259,8 @@ export async function interactWithFeed(session, url, actions, commentContent) {
     }
     const page = await getOrCreateXiaohongshuPage(session);
     await waitForInteractContainer(page);
-    let liked = detailItem.note.interactInfo.liked === true;
-    let collected = detailItem.note.interactInfo.collected === true;
+    let liked = detailItem.note.liked === true;
+    let collected = detailItem.note.collected === true;
     const messages = [];
     for (const action of actions){
         if (action === 'like') {
@@ -280,17 +286,34 @@ export async function interactWithFeed(session, url, actions, commentContent) {
         message: `${messages.join('; ')}: ${url}`
     };
 }
+async function resolveInteractUrl(values, instanceName) {
+    if (values.id) {
+        if (!instanceName) {
+            throw new Error('The --id option requires an instance-backed session.');
+        }
+        const url = await findPersistedPostUrlByRecordId(instanceName, ensureNonEmpty(values.id, '--id'));
+        if (!url) {
+            throw new Error(`No saved post url found for id: ${values.id}`);
+        }
+        return url;
+    }
+    if (values.url) {
+        return ensureNonEmpty(values.url, '--url');
+    }
+    throw new Error('Missing required option: --id or --url');
+}
 export async function runInteractCommand(values = {}) {
     if (values.help) {
         printInteractHelp();
         return;
     }
-    const url = ensureNonEmpty(values.url, '--url');
     const { actions, commentContent } = resolveInteractActions(values);
+    await initializeRednoteDatabase();
     const target = resolveStatusTarget(values.instance);
     const session = await createRednoteSession(target);
     try {
         await ensureRednoteLoggedIn(target, `performing ${actions.join(', ')} interact`, session);
+        const url = await resolveInteractUrl(values, target.instanceName);
         const result = await interactWithFeed(session, url, actions, commentContent);
         printJson(result);
     } finally{

package/dist/rednote/login.js

@@ -103,13 +103,11 @@ export async function openRednoteLogin(target, session) {
     if (!rednoteStatus.needLogin) {
         return {
             ok: true,
-            rednote: {
-                loginClicked: false,
-                pageUrl: session.page.url(),
-                waitingForPhoneLogin: false,
-                qrCodePath: null,
-                message: 'The current instance is already logged in. No additional login step is required.'
-            }
+            loginClicked: false,
+            pageUrl: session.page.url(),
+            waitingForPhoneLogin: false,
+            qrCodePath: null,
+            message: 'The current instance is already logged in. No additional login step is required.'
         };
     }
     const { page } = await getOrCreateXiaohongshuPage(session);
@@ -119,13 +117,11 @@ export async function openRednoteLogin(target, session) {
     if (!hasLoginButton) {
         return {
             ok: true,
-            rednote: {
-                loginClicked: false,
-                pageUrl: page.url(),
-                waitingForPhoneLogin: false,
-                qrCodePath: null,
-                message: 'No login button was found. The current instance may already be logged in.'
-            }
+            loginClicked: false,
+            pageUrl: page.url(),
+            waitingForPhoneLogin: false,
+            qrCodePath: null,
+            message: 'No login button was found. The current instance may already be logged in.'
         };
     }
     await loginButton.first().click({
@@ -136,13 +132,11 @@ export async function openRednoteLogin(target, session) {
     const qrCodePath = await saveQrCodeImage(page);
     return {
         ok: true,
-        rednote: {
-            loginClicked: true,
-            pageUrl: page.url(),
-            waitingForPhoneLogin: true,
-            qrCodePath,
-            message: 'The login button was clicked and the QR code image was exported. Scan the code to finish logging in.'
-        }
+        loginClicked: true,
+        pageUrl: page.url(),
+        waitingForPhoneLogin: true,
+        qrCodePath,
+        message: 'The login button was clicked and the QR code image was exported. Scan the code to finish logging in.'
     };
 }
 export async function runLoginCommand(values = {}) {