@skills-store/rednote 0.1.15 → 0.1.16

package/dist/browser/connect-browser.js

@@ -9,44 +9,70 @@ async function resolveBrowserPid(remoteDebuggingPort, detectedPid) {
     return portPids[0] ?? null;
 }
 export async function resolveConnectOptions(options) {
-    if (!options.instanceName) {
+    if (options.instanceName) {
+        if (options.userDataDir) {
+            throw new Error('Do not combine --instance with --user-data-dir');
+        }
+        if (options.browser) {
+            throw new Error('Do not combine --instance with --browser');
+        }
+        const store = readInstanceStore();
+        const instanceName = validateInstanceName(options.instanceName);
+        const persisted = store.instances.find((instance)=>instance.name === instanceName);
+        if (!persisted) {
+            throw new Error(`Unknown instance: ${instanceName}`);
+        }
+        let remoteDebuggingPort = options.remoteDebuggingPort ?? persisted.remoteDebuggingPort;
+        if (!remoteDebuggingPort) {
+            remoteDebuggingPort = await getRandomAvailablePort();
+            updateInstanceRemoteDebuggingPort(instanceName, remoteDebuggingPort);
+        }
         return {
-            connectOptions: options,
-            lastConnect: options.userDataDir ? null : {
-                scope: 'default',
-                name: options.browser ?? 'chrome',
-                browser: options.browser ?? 'chrome'
+            connectOptions: {
+                ...options,
+                browser: persisted.browser,
+                userDataDir: persisted.userDataDir,
+                remoteDebuggingPort
+            },
+            lastConnect: {
+                scope: 'custom',
+                name: persisted.name,
+                browser: persisted.browser
             }
         };
     }
-    if (options.userDataDir) {
-        throw new Error('Do not combine --instance with --user-data-dir');
-    }
-    if (options.browser) {
-        throw new Error('Do not combine --instance with --browser');
-    }
     const store = readInstanceStore();
-    const instanceName = validateInstanceName(options.instanceName);
-    const persisted = store.instances.find((instance)=>instance.name === instanceName);
-    if (!persisted) {
-        throw new Error(`Unknown instance: ${instanceName}`);
-    }
-    let remoteDebuggingPort = options.remoteDebuggingPort ?? persisted.remoteDebuggingPort;
-    if (!remoteDebuggingPort) {
-        remoteDebuggingPort = await getRandomAvailablePort();
-        updateInstanceRemoteDebuggingPort(instanceName, remoteDebuggingPort);
+    const lastConnect = store.lastConnect;
+    if (lastConnect && lastConnect.scope === 'custom') {
+        const persisted = store.instances.find((instance)=>instance.name === lastConnect.name);
+        if (persisted) {
+            let remoteDebuggingPort = options.remoteDebuggingPort ?? persisted.remoteDebuggingPort;
+            if (!remoteDebuggingPort) {
+                remoteDebuggingPort = await getRandomAvailablePort();
+                updateInstanceRemoteDebuggingPort(lastConnect.name, remoteDebuggingPort);
+            }
+            return {
+                connectOptions: {
+                    ...options,
+                    instanceName: persisted.name,
+                    browser: persisted.browser,
+                    userDataDir: persisted.userDataDir,
+                    remoteDebuggingPort
+                },
+                lastConnect: {
+                    scope: 'custom',
+                    name: persisted.name,
+                    browser: persisted.browser
+                }
+            };
+        }
     }
     return {
-        connectOptions: {
-            ...options,
-            browser: persisted.browser,
-            userDataDir: persisted.userDataDir,
-            remoteDebuggingPort
-        },
-        lastConnect: {
-            scope: 'custom',
-            name: persisted.name,
-            browser: persisted.browser
+        connectOptions: options,
+        lastConnect: options.userDataDir ? null : {
+            scope: 'default',
+            name: options.browser ?? 'chrome',
+            browser: options.browser ?? 'chrome'
         }
     };
 }
@@ -86,6 +112,7 @@ export async function initBrowser(options = {}) {
         });
         return {
             ok: true,
+            instanceName: options.instanceName,
             type: spec.type,
             executablePath,
             userDataDir,
@@ -135,6 +162,7 @@ export async function initBrowser(options = {}) {
     }
     return {
         ok: true,
+        instanceName: options.instanceName ?? null,
         type: spec.type,
         executablePath,
         userDataDir,

package/dist/rednote/checkLogin.js

@@ -83,8 +83,14 @@ export async function checkRednoteLogin(target, session) {
             pageUrl: page.url(),
             needLogin
         });
+        let userId;
+        if (!needLogin) {
+            const locator = page.locator("li.user a").first();
+            userId = (await locator.getAttribute("href"))?.split('/').pop();
+        }
         return {
             loginStatus: needLogin ? 'logged-out' : 'logged-in',
+            userId: userId ?? null,
             lastLoginAt: null,
             needLogin,
             checkedAt: new Date().toISOString()

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

@@ -16,6 +16,7 @@ Commands:
   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
@@ -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/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 = {}) {

package/dist/rednote/persistence.js

@@ -289,6 +289,96 @@ const rednotePostCommentSchema = new EntitySchema({
         }
     ]
 });
+const rednoteProfileSchema = new EntitySchema({
+    name: 'RednoteProfileRecord',
+    tableName: 'rednote_profiles',
+    columns: {
+        id: {
+            type: String,
+            primary: true,
+            length: 16
+        },
+        userId: {
+            name: 'userid',
+            type: String
+        },
+        nickname: {
+            type: String,
+            nullable: true
+        },
+        desc: {
+            type: 'text',
+            nullable: true
+        },
+        avatar: {
+            type: String,
+            nullable: true
+        },
+        ipLocation: {
+            name: 'ip_location',
+            type: String,
+            nullable: true
+        },
+        gender: {
+            type: String,
+            nullable: true
+        },
+        follows: {
+            type: String,
+            nullable: true
+        },
+        fans: {
+            type: String,
+            nullable: true
+        },
+        interaction: {
+            type: String,
+            nullable: true
+        },
+        tags: {
+            type: 'simple-json',
+            nullable: true
+        },
+        fetchedAt: {
+            name: 'fetched_at',
+            type: Date
+        },
+        instanceName: {
+            name: 'instance_name',
+            type: String
+        },
+        raw: {
+            type: 'simple-json',
+            nullable: true
+        },
+        createdAt: {
+            name: 'created_at',
+            type: Date,
+            createDate: true
+        }
+    },
+    indices: [
+        {
+            name: 'IDX_rednote_profiles_userid_instance',
+            columns: [
+                'userId',
+                'instanceName'
+            ]
+        },
+        {
+            name: 'IDX_rednote_profiles_fetched_at',
+            columns: [
+                'fetchedAt'
+            ]
+        },
+        {
+            name: 'IDX_rednote_profiles_instance',
+            columns: [
+                'instanceName'
+            ]
+        }
+    ]
+});
 let dataSourcePromise = null;
 function createRecordId() {
     return nanoid(16);
@@ -360,7 +450,8 @@ async function initializeDataSource() {
         entities: [
             rednotePostSchema,
             rednotePostDetailSchema,
-            rednotePostCommentSchema
+            rednotePostCommentSchema,
+            rednoteProfileSchema
         ],
         synchronize: true,
         logging: false,
@@ -576,3 +667,98 @@ export async function findPersistedPostUrlByRecordId(instanceName, id) {
     });
     return row?.url ?? null;
 }
+export async function persistProfile(input) {
+    const { instanceName, result } = input;
+    const { profile } = result;
+    const { user, notes, userId, url, fetchedAt } = profile;
+    const dataSource = await initializeRednoteDatabase();
+    await dataSource.transaction(async (manager)=>{
+        const profileRepository = manager.getRepository(rednoteProfileSchema);
+        const postRepository = manager.getRepository(rednotePostSchema);
+        await profileRepository.save(profileRepository.create({
+            id: createRecordId(),
+            userId,
+            nickname: user.nickname,
+            desc: user.desc,
+            avatar: user.avatar,
+            ipLocation: user.ipLocation,
+            gender: user.gender,
+            follows: toCountString(user.follows),
+            fans: toCountString(user.fans),
+            interaction: toCountString(user.interaction),
+            tags: user.tags,
+            fetchedAt: new Date(fetchedAt),
+            instanceName,
+            raw: user
+        }));
+        if (notes.length > 0) {
+            const noteIds = uniqueStrings(notes.map((note)=>note.id));
+            const existingRows = noteIds.length > 0 ? await postRepository.find({
+                where: {
+                    instanceName,
+                    noteId: In(noteIds)
+                }
+            }) : [];
+            const existingMap = new Map(existingRows.map((row)=>[
+                    row.noteId,
+                    row
+                ]));
+            const entities = notes.map((post)=>{
+                const existing = existingMap.get(post.id);
+                const image = extractPrimaryImage(post);
+                const authorNickname = firstNonEmpty(post.noteCard.user.nickname, post.noteCard.user.nickName);
+                return postRepository.create({
+                    id: existing?.id ?? createRecordId(),
+                    noteId: post.id,
+                    title: coalesceValue(post.noteCard.displayTitle, existing?.title),
+                    url: coalesceValue(post.url, existing?.url),
+                    image: coalesceValue(image, existing?.image),
+                    likeCount: coalesceValue(toCountString(post.noteCard.interactInfo.likedCount), existing?.likeCount),
+                    commentCount: coalesceValue(toCountString(post.noteCard.interactInfo.commentCount), existing?.commentCount),
+                    collectedCount: coalesceValue(toCountString(post.noteCard.interactInfo.collectedCount), existing?.collectedCount),
+                    sharedCount: coalesceValue(toCountString(post.noteCard.interactInfo.sharedCount), existing?.sharedCount),
+                    authorId: coalesceValue(post.noteCard.user.userId, existing?.authorId),
+                    authorNickname: coalesceValue(authorNickname, existing?.authorNickname),
+                    modelType: coalesceValue(post.modelType, existing?.modelType),
+                    xsecToken: coalesceValue(post.xsecToken, existing?.xsecToken),
+                    instanceName,
+                    raw: post,
+                    ...existing?.createdAt ? {
+                        createdAt: existing.createdAt
+                    } : {}
+                });
+            });
+            await postRepository.save(entities);
+        }
+    });
+}
+export async function getProfileHistory(instanceName, userId, options) {
+    const dataSource = await initializeRednoteDatabase();
+    const repository = dataSource.getRepository(rednoteProfileSchema);
+    const rows = await repository.find({
+        where: {
+            instanceName,
+            userId
+        },
+        order: {
+            fetchedAt: 'DESC'
+        },
+        take: options?.limit ?? 100
+    });
+    return rows.map((row)=>({
+            id: row.id,
+            userId: row.userId,
+            nickname: row.nickname,
+            desc: row.desc,
+            avatar: row.avatar,
+            ipLocation: row.ipLocation,
+            gender: row.gender,
+            follows: row.follows,
+            fans: row.fans,
+            interaction: row.interaction,
+            tags: row.tags,
+            fetchedAt: row.fetchedAt,
+            instanceName: row.instanceName,
+            createdAt: row.createdAt
+        }));
+}

package/dist/rednote/status.js

@@ -23,6 +23,9 @@ Usage:
 Options:
   --instance NAME   Show status for a custom instance or default browser instance
   -h, --help        Show this help
+
+Notes:
+  When called without --instance, it uses the last connected instance from data.json (lastConnect).
 `);
 }
 function toInstanceState(instance) {
@@ -136,6 +139,7 @@ export async function getRednoteStatus(target) {
                 checked
             });
             rednote = {
+                userId: checked.userId,
                 loginStatus: checked.loginStatus,
                 lastLoginAt: checked.lastLoginAt
             };

package/dist/utils/browser-cli.js

@@ -103,6 +103,7 @@ Usage:
   bun ./scripts/browser/connect-browser.ts [--instance NAME] [--browser chrome|edge|chromium|brave] [--user-data-dir PATH] [--force] [--port 9222]
 
 Notes:
+  When called without --instance, it uses the last connected instance from data.json (lastConnect).
   When using --instance without --port, the stored instance port from data.json is used.
   If no stored port exists yet, a random free port is assigned and saved for next time.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skills-store/rednote",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "private": false,
   "type": "module",
   "bin": {