@skills-store/rednote 0.1.0 → 0.1.2

package/bin/rednote.js

@@ -1,27 +1,19 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { runRootCli } from '../dist/index.js';
+import { stringifyError } from '../dist/utils/browser-cli.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const entry = path.resolve(__dirname, '../scripts/index.ts');
-
-const child = spawn(process.execPath, ['--experimental-strip-types', entry, ...process.argv.slice(2)], {
-  stdio: 'inherit',
-  env: process.env,
-});
-
-child.on('exit', (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-
-  process.exit(code ?? 1);
-});
-
-child.on('error', (error) => {
-  console.error(error instanceof Error ? error.message : String(error));
+try {
+  await runRootCli(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(
+    `${JSON.stringify(
+      {
+        ok: false,
+        error: stringifyError(error),
+      },
+      null,
+      2,
+    )}\n`,
+  );
   process.exit(1);
-});
+}

package/dist/browser/connect-browser.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { closeProcessesByPid, findSpec, getCdpWebSocketUrl, getPidsListeningOnPort, inspectBrowserInstance, getRandomAvailablePort, launchBrowser, removeLockFiles, readInstanceStore, resolveExecutablePath, resolveUserDataDir, updateInstanceRemoteDebuggingPort, updateLastConnect, validateInstanceName, waitForCdpReady, waitForPortToClose } from '../utils/browser-core.js';
+import { parseBrowserCliArgs, printConnectBrowserHelp, printJson, runCli, debugLog } from '../utils/browser-cli.js';
+async function resolveBrowserPid(remoteDebuggingPort, detectedPid) {
+    if (detectedPid) {
+        return detectedPid;
+    }
+    const portPids = await getPidsListeningOnPort(remoteDebuggingPort);
+    return portPids[0] ?? null;
+}
+export async function resolveConnectOptions(options) {
+    if (!options.instanceName) {
+        return {
+            connectOptions: options,
+            lastConnect: options.userDataDir ? null : {
+                scope: 'default',
+                name: options.browser ?? 'chrome',
+                browser: options.browser ?? 'chrome'
+            }
+        };
+    }
+    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,
+            browser: persisted.browser,
+            userDataDir: persisted.userDataDir,
+            remoteDebuggingPort
+        },
+        lastConnect: {
+            scope: 'custom',
+            name: persisted.name,
+            browser: persisted.browser
+        }
+    };
+}
+export async function initBrowser(options = {}) {
+    debugLog('initBrowser', 'start', {
+        options
+    });
+    const browserType = options.browser ?? 'chrome';
+    const spec = findSpec(browserType);
+    const executablePath = options.executablePath || resolveExecutablePath(spec);
+    if (!executablePath) {
+        throw new Error(`No executable found for ${spec.displayName}`);
+    }
+    const userDataDir = resolveUserDataDir(spec, options);
+    const remoteDebuggingPort = options.remoteDebuggingPort ?? 9222;
+    const connectTimeoutMs = options.connectTimeoutMs ?? 15_000;
+    const killTimeoutMs = options.killTimeoutMs ?? 8_000;
+    const startupUrl = options.startupUrl ?? 'about:blank';
+    const detectedInstance = await inspectBrowserInstance(spec, executablePath, userDataDir);
+    debugLog('initBrowser', 'inspected instance', {
+        browserType,
+        executablePath,
+        userDataDir,
+        remoteDebuggingPort,
+        detectedInstance
+    });
+    const closedPidSet = new Set();
+    const existingWsUrl = await getCdpWebSocketUrl(remoteDebuggingPort);
+    debugLog('initBrowser', 'checked existing ws url', {
+        remoteDebuggingPort,
+        existingWsUrl
+    });
+    if (existingWsUrl) {
+        debugLog('initBrowser', 'reusing existing ws url', {
+            remoteDebuggingPort,
+            existingWsUrl
+        });
+        return {
+            ok: true,
+            type: spec.type,
+            executablePath,
+            userDataDir,
+            remoteDebuggingPort,
+            wsUrl: existingWsUrl,
+            pid: await resolveBrowserPid(remoteDebuggingPort, detectedInstance.pid)
+        };
+    }
+    if (detectedInstance.inUse && detectedInstance.remotePort === null) {
+        if (!options.force) {
+            throw new Error(`Browser profile is already in use without a remote debugging port. Re-run with --force to safely close it first: ${detectedInstance.userDataDir}`);
+        }
+        if (detectedInstance.pids.length === 0) {
+            throw new Error(`Browser profile is in use but no running browser PID was found for safe shutdown: ${detectedInstance.userDataDir}`);
+        }
+    }
+    if (detectedInstance.inUse && detectedInstance.pids.length > 0) {
+        debugLog('initBrowser', 'detected in-use profile, closing existing processes', {
+            pids: detectedInstance.pids,
+            killTimeoutMs,
+            remoteDebuggingPort
+        });
+        for (const pid of (await closeProcessesByPid(detectedInstance.pids, killTimeoutMs))){
+            closedPidSet.add(pid);
+        }
+        await waitForPortToClose(remoteDebuggingPort, killTimeoutMs);
+    } else if (detectedInstance.staleLock) {
+        if (!options.force) {
+            throw new Error(`Profile is locked by stale files: ${detectedInstance.lockFiles.join(', ')}`);
+        }
+        removeLockFiles(detectedInstance.lockFiles);
+    }
+    const launched = await launchBrowser(spec, executablePath, userDataDir, remoteDebuggingPort, startupUrl);
+    debugLog('initBrowser', 'launched browser', {
+        remoteDebuggingPort,
+        pid: launched.pid ?? null,
+        startupUrl
+    });
+    const wsUrl = await waitForCdpReady(remoteDebuggingPort, connectTimeoutMs);
+    debugLog('initBrowser', 'waited for cdp ready', {
+        remoteDebuggingPort,
+        connectTimeoutMs,
+        wsUrl
+    });
+    if (!wsUrl) {
+        throw new Error(`CDP did not become available on port ${remoteDebuggingPort}`);
+    }
+    return {
+        ok: true,
+        type: spec.type,
+        executablePath,
+        userDataDir,
+        remoteDebuggingPort,
+        wsUrl,
+        pid: launched.pid ?? await resolveBrowserPid(remoteDebuggingPort, detectedInstance.pid)
+    };
+}
+export async function runConnectBrowserCommand(values) {
+    const resolved = await resolveConnectOptions({
+        browser: values.browser,
+        instanceName: values.instance,
+        executablePath: values['executable-path'],
+        userDataDir: values['user-data-dir'],
+        force: values.force,
+        remoteDebuggingPort: values.port ? Number(values.port) : undefined,
+        connectTimeoutMs: values.timeout ? Number(values.timeout) : undefined,
+        killTimeoutMs: values['kill-timeout'] ? Number(values['kill-timeout']) : undefined,
+        startupUrl: values['startup-url']
+    });
+    const result = await initBrowser(resolved.connectOptions);
+    if (resolved.lastConnect) {
+        updateLastConnect(resolved.lastConnect);
+    }
+    printJson(result);
+}
+async function main() {
+    const { values } = parseBrowserCliArgs(process.argv.slice(2));
+    if (values.help) {
+        printConnectBrowserHelp();
+        return;
+    }
+    await runConnectBrowserCommand(values);
+}
+runCli(import.meta.url, main);

package/dist/browser/create-browser.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { customInstanceUserDataDir, ensureDir, isDefaultInstanceName, readInstanceStore, validateInstanceName, writeInstanceStore } from '../utils/browser-core.js';
+import { parseBrowserCliArgs, printCreateBrowserHelp, printJson, runCli } from '../utils/browser-cli.js';
+export function createBrowserInstance(options) {
+    const store = readInstanceStore();
+    const name = validateInstanceName(options.name);
+    const browser = options.browser ?? 'chrome';
+    if (isDefaultInstanceName(name)) {
+        throw new Error(`Instance name is reserved for a default browser: ${name}`);
+    }
+    if (store.instances.some((instance)=>instance.name === name)) {
+        throw new Error(`Instance already exists: ${name}`);
+    }
+    const instance = {
+        name,
+        browser,
+        userDataDir: ensureDir(customInstanceUserDataDir(name)),
+        createdAt: new Date().toISOString(),
+        remoteDebuggingPort: typeof options.remoteDebuggingPort === 'number' && Number.isInteger(options.remoteDebuggingPort) && options.remoteDebuggingPort > 0 ? options.remoteDebuggingPort : undefined
+    };
+    writeInstanceStore({
+        ...store,
+        instances: [
+            ...store.instances,
+            instance
+        ]
+    });
+    return {
+        ok: true,
+        instance
+    };
+}
+export function runCreateBrowserCommand(values) {
+    if (!values.name) {
+        throw new Error('Missing required option: --name');
+    }
+    const result = createBrowserInstance({
+        name: values.name,
+        browser: values.browser,
+        remoteDebuggingPort: values.port ? Number(values.port) : undefined
+    });
+    printJson(result);
+}
+async function main() {
+    const { values } = parseBrowserCliArgs(process.argv.slice(2));
+    if (values.help) {
+        printCreateBrowserHelp();
+        return;
+    }
+    runCreateBrowserCommand(values);
+}
+runCli(import.meta.url, main);

package/dist/browser/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { parseBrowserCliArgs, printInitBrowserHelp, runCli } from '../utils/browser-cli.js';
+export async function runBrowserCli(argv = process.argv.slice(2)) {
+    const { values, positionals } = parseBrowserCliArgs(argv);
+    const command = positionals[0] || 'list';
+    if (values.help || command === 'help') {
+        printInitBrowserHelp();
+        return;
+    }
+    if (command === 'list') {
+        const { runListBrowserCommand } = await import('./list-browser.js');
+        await runListBrowserCommand(values);
+        return;
+    }
+    if (command === 'create') {
+        const { runCreateBrowserCommand } = await import('./create-browser.js');
+        runCreateBrowserCommand(values);
+        return;
+    }
+    if (command === 'remove') {
+        const { runRemoveBrowserCommand } = await import('./remove-browser.js');
+        await runRemoveBrowserCommand(values);
+        return;
+    }
+    if (command === 'connect') {
+        const { runConnectBrowserCommand } = await import('./connect-browser.js');
+        await runConnectBrowserCommand(values);
+        return;
+    }
+    throw new Error(`Unknown browser command: ${command}`);
+}
+async function main() {
+    await runBrowserCli();
+}
+runCli(import.meta.url, main);

package/dist/browser/list-browser.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { browserSpecs, findSpec, inspectBrowserInstance, isLastConnectMatch, readInstanceStore, toBrowserInstanceInfo } from '../utils/browser-core.js';
+import { parseBrowserCliArgs, printJson, printListBrowserHelp, runCli } from '../utils/browser-cli.js';
+export async function listBrowserInstances() {
+    const specs = browserSpecs();
+    const store = readInstanceStore();
+    const defaultInstances = await Promise.all(specs.map(async (spec)=>{
+        const instance = await inspectBrowserInstance(spec);
+        return {
+            ...toBrowserInstanceInfo(instance),
+            scope: 'default',
+            instanceName: spec.type,
+            createdAt: null,
+            lastConnect: isLastConnectMatch(store.lastConnect, 'default', spec.type, spec.type)
+        };
+    }));
+    const customInstances = await Promise.all(store.instances.map(async (persisted)=>{
+        const spec = findSpec(persisted.browser);
+        const instance = await inspectBrowserInstance(spec, undefined, persisted.userDataDir);
+        return {
+            ...toBrowserInstanceInfo(instance),
+            name: persisted.name,
+            userDataDir: persisted.userDataDir,
+            scope: 'custom',
+            instanceName: persisted.name,
+            createdAt: persisted.createdAt,
+            lastConnect: isLastConnectMatch(store.lastConnect, 'custom', persisted.name, persisted.browser)
+        };
+    }));
+    return {
+        lastConnect: store.lastConnect,
+        instances: [
+            ...defaultInstances,
+            ...customInstances
+        ]
+    };
+}
+export async function runListBrowserCommand(_values) {
+    const instances = await listBrowserInstances();
+    printJson(instances);
+}
+async function main() {
+    const { values } = parseBrowserCliArgs(process.argv.slice(2));
+    if (values.help) {
+        printListBrowserHelp();
+        return;
+    }
+    await runListBrowserCommand(values);
+}
+runCli(import.meta.url, main);

package/dist/browser/remove-browser.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { closeProcessesByPid, customInstanceUserDataDir, exists, findSpec, inspectBrowserInstance, INSTANCES_DIR, isDefaultInstanceName, isSubPath, normalizePath, readInstanceStore, validateInstanceName, waitForPortToClose, writeInstanceStore } from '../utils/browser-core.js';
+import { parseBrowserCliArgs, printJson, printRemoveBrowserHelp, runCli } from '../utils/browser-cli.js';
+export async function removeBrowserInstance(options) {
+    const store = readInstanceStore();
+    const name = validateInstanceName(options.name);
+    if (isDefaultInstanceName(name)) {
+        throw new Error(`Default instance cannot be removed: ${name}`);
+    }
+    const instance = store.instances.find((item)=>item.name === name);
+    if (!instance) {
+        throw new Error(`Instance not found: ${name}`);
+    }
+    const expectedUserDataDir = customInstanceUserDataDir(name);
+    const resolvedUserDataDir = normalizePath(instance.userDataDir);
+    if (!isSubPath(INSTANCES_DIR, resolvedUserDataDir) || normalizePath(expectedUserDataDir) !== resolvedUserDataDir) {
+        throw new Error(`Refusing to remove unexpected instance directory: ${instance.userDataDir}`);
+    }
+    const spec = findSpec(instance.browser);
+    const detectedInstance = await inspectBrowserInstance(spec, undefined, resolvedUserDataDir);
+    if (detectedInstance.inUse && !options.force) {
+        throw new Error(`Instance is currently in use. Re-run with --force: ${name}`);
+    }
+    const closedPids = [];
+    if (options.force && detectedInstance.pids.length > 0) {
+        for (const pid of (await closeProcessesByPid(detectedInstance.pids, 8_000))){
+            closedPids.push(pid);
+        }
+        if (detectedInstance.remotePort !== null) {
+            await waitForPortToClose(detectedInstance.remotePort, 8_000);
+        }
+    }
+    const removedDir = exists(resolvedUserDataDir);
+    fs.rmSync(resolvedUserDataDir, {
+        recursive: true,
+        force: true
+    });
+    writeInstanceStore({
+        ...store,
+        lastConnect: store.lastConnect?.scope === 'custom' && store.lastConnect.name === instance.name && store.lastConnect.browser === instance.browser ? null : store.lastConnect,
+        instances: store.instances.filter((item)=>item.name !== instance.name)
+    });
+    return {
+        ok: true,
+        removedInstance: instance,
+        removedDir,
+        closedPids
+    };
+}
+export async function runRemoveBrowserCommand(values) {
+    if (!values.name) {
+        throw new Error('Missing required option: --name');
+    }
+    const result = await removeBrowserInstance({
+        name: values.name,
+        force: values.force
+    });
+    printJson(result);
+}
+async function main() {
+    const { values } = parseBrowserCliArgs(process.argv.slice(2));
+    if (values.help) {
+        process.stdout.write(`remove-browser\n\nUsage:\n  node --experimental-strip-types ./scripts/browser/remove-browser.ts --name NAME [--force]\n  bun ./scripts/browser/remove-browser.ts --name NAME [--force]\n`);
+        return;
+    }
+    await runRemoveBrowserCommand(values);
+}
+runCli(import.meta.url, main);

package/{scripts/index.ts → dist/index.js}

@@ -1,9 +1,7 @@
-#!/usr/bin/env -S node --experimental-strip-types
-
-import { runCli } from './utils/browser-cli.ts';
-
+#!/usr/bin/env node
+import { runCli } from './utils/browser-cli.js';
 function printRootHelp() {
-  process.stdout.write(`rednote
+    process.stdout.write(`rednote
 
 Usage:
   npx -y @skills-store/rednote browser <command> [...args]
@@ -15,6 +13,7 @@ Commands:
   status [--instance NAME]
   check-login [--instance NAME]
   login [--instance NAME]
+  publish [--instance NAME]
   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 [--format md|json]
@@ -25,30 +24,25 @@ Examples:
   npx -y @skills-store/rednote browser create --name seller-main --browser chrome
   npx -y @skills-store/rednote browser connect --instance seller-main
   npx -y @skills-store/rednote env
+  npx -y @skills-store/rednote publish --instance seller-main --type video --video ./note.mp4 --title 标题 --content 描述
   npx -y @skills-store/rednote search --instance seller-main --keyword 护肤
 `);
 }
-
-export async function runRootCli(argv: string[] = process.argv.slice(2)) {
-  const [command, ...restArgv] = argv;
-
-  if (!command || command === 'help' || command === '--help' || command === '-h') {
-    printRootHelp();
-    return;
-  }
-
-  if (command === 'browser') {
-    const { runBrowserCli } = await import('./browser/index.ts');
-    await runBrowserCli(restArgv);
-    return;
-  }
-
-  const { runRednoteCli } = await import('./rednote/index.ts');
-  await runRednoteCli(argv);
+export async function runRootCli(argv = process.argv.slice(2)) {
+    const [command, ...restArgv] = argv;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        printRootHelp();
+        return;
+    }
+    if (command === 'browser') {
+        const { runBrowserCli } = await import('./browser/index.js');
+        await runBrowserCli(restArgv);
+        return;
+    }
+    const { runRednoteCli } = await import('./rednote/index.js');
+    await runRednoteCli(argv);
 }
-
 async function main() {
-  await runRootCli();
+    await runRootCli();
 }
-
 runCli(import.meta.url, main);

package/dist/rednote/checkLogin.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { initBrowser, resolveConnectOptions } from '../browser/connect-browser.js';
+import { connectOverCdp, updateLastConnect } from '../utils/browser-core.js';
+import { debugLog, printJson, runCli } from '../utils/browser-cli.js';
+import { resolveStatusTarget } from './status.js';
+function printCheckLoginHelp() {
+    process.stdout.write(`rednote check-login
+
+Usage:
+  npx -y @skills-store/rednote check-login [--instance NAME]
+  node --experimental-strip-types ./scripts/rednote/checkLogin.ts --instance NAME
+  bun ./scripts/rednote/checkLogin.ts --instance NAME
+
+Options:
+  --instance NAME   Optional. Defaults to the saved lastConnect instance
+  -h, --help        Show this help
+`);
+}
+export async function createRednoteSession(target) {
+    debugLog('checkLogin', 'create session start', {
+        target
+    });
+    const resolved = await resolveConnectOptions(target.scope === 'custom' ? {
+        instanceName: target.instanceName
+    } : {
+        browser: target.browser
+    });
+    const launched = await initBrowser(resolved.connectOptions);
+    debugLog('checkLogin', 'initBrowser resolved', {
+        target,
+        connectOptions: resolved.connectOptions,
+        launched
+    });
+    if (resolved.lastConnect) {
+        updateLastConnect(resolved.lastConnect);
+    }
+    const browser = await connectOverCdp(launched.wsUrl);
+    debugLog('checkLogin', 'connected over cdp', {
+        wsUrl: launched.wsUrl,
+        remoteDebuggingPort: launched.remoteDebuggingPort
+    });
+    const browserContext = browser.contexts()[0];
+    if (!browserContext) {
+        throw new Error(`No browser context found for instance: ${target.instanceName}`);
+    }
+    const page = browserContext.pages().find((candidate)=>candidate.url().startsWith('https://www.xiaohongshu.com/')) ?? await browserContext.newPage();
+    debugLog('checkLogin', 'session page resolved', {
+        pageUrl: page.url(),
+        totalPages: browserContext.pages().length
+    });
+    return {
+        browser,
+        browserContext,
+        page
+    };
+}
+export function disconnectRednoteSession(session) {
+    try {
+        session.browser._connection?.close();
+    } catch  {}
+}
+export async function checkRednoteLogin(target, session) {
+    const ownsSession = !session;
+    const activeSession = session ?? await createRednoteSession(target);
+    try {
+        debugLog('checkLogin', 'check login start', {
+            target,
+            reusedSession: Boolean(session)
+        });
+        const page = activeSession.page;
+        if (!page.url().startsWith('https://www.xiaohongshu.com/')) {
+            debugLog('checkLogin', 'page is not on xiaohongshu, navigating', {
+                currentUrl: page.url()
+            });
+            await page.goto('https://www.xiaohongshu.com/explore', {
+                waitUntil: 'domcontentloaded'
+            });
+        }
+        await page.waitForTimeout(2_000);
+        const needLogin = await page.locator('#login-btn').count() > 0;
+        debugLog('checkLogin', 'login state checked', {
+            pageUrl: page.url(),
+            needLogin
+        });
+        return {
+            loginStatus: needLogin ? 'logged-out' : 'logged-in',
+            lastLoginAt: null,
+            needLogin,
+            checkedAt: new Date().toISOString()
+        };
+    } finally{
+        if (ownsSession) {
+            disconnectRednoteSession(activeSession);
+        }
+    }
+}
+export async function ensureRednoteLoggedIn(target, action = 'continue', session) {
+    const rednote = await checkRednoteLogin(target, session);
+    if (rednote.needLogin) {
+        throw new Error(`Xiaohongshu login is required before ${action}. Run \`rednote login --instance ${target.instanceName}\` first.`);
+    }
+    return rednote;
+}
+export async function runCheckLoginCommand(values = {}) {
+    if (values.help) {
+        printCheckLoginHelp();
+        return;
+    }
+    const target = resolveStatusTarget(values.instance);
+    const rednote = await checkRednoteLogin(target);
+    const result = {
+        ok: true,
+        rednote
+    };
+    printJson(result);
+}
+async function main() {
+    const { values } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        strict: false,
+        options: {
+            instance: {
+                type: 'string'
+            },
+            help: {
+                type: 'boolean',
+                short: 'h'
+            }
+        }
+    });
+    if (values.help) {
+        printCheckLoginHelp();
+        return;
+    }
+    await runCheckLoginCommand(values);
+}
+runCli(import.meta.url, main);