@skills-store/rednote 0.1.0 → 0.1.2

package/dist/rednote/status.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { findSpec, inspectBrowserInstance, isDefaultInstanceName, isLastConnectMatch, readInstanceStore } from '../utils/browser-core.js';
+import { debugLog, printJson, runCli, stringifyError } from '../utils/browser-cli.js';
+let rednoteAccountStatusProvider = async ()=>({
+        loginStatus: 'unknown',
+        lastLoginAt: null
+    });
+export function registerRednoteAccountStatusProvider(provider) {
+    rednoteAccountStatusProvider = provider;
+}
+export async function getRednoteAccountStatus(context) {
+    return await rednoteAccountStatusProvider(context);
+}
+function printStatusHelp() {
+    process.stdout.write(`rednote status
+
+Usage:
+  npx -y @skills-store/rednote status [--instance NAME]
+  node --experimental-strip-types ./scripts/rednote/status.ts [--instance NAME]
+  bun ./scripts/rednote/status.ts [--instance NAME]
+
+Options:
+  --instance NAME   Show status for a custom instance or default browser instance
+  -h, --help        Show this help
+`);
+}
+function toInstanceState(instance) {
+    if (instance.staleLock) {
+        return 'stale-lock';
+    }
+    if (instance.inUse) {
+        return 'running';
+    }
+    if (instance.exists) {
+        return 'stopped';
+    }
+    return 'missing';
+}
+function fromPersistedInstance(instance, source) {
+    const store = readInstanceStore();
+    return {
+        scope: 'custom',
+        instanceName: instance.name,
+        browser: instance.browser,
+        userDataDir: instance.userDataDir,
+        createdAt: instance.createdAt,
+        lastConnect: isLastConnectMatch(store.lastConnect, 'custom', instance.name, instance.browser),
+        source
+    };
+}
+export function resolveStatusTarget(instanceName) {
+    const store = readInstanceStore();
+    if (instanceName) {
+        const normalizedName = instanceName.trim();
+        if (!normalizedName) {
+            throw new Error('Instance name cannot be empty');
+        }
+        if (isDefaultInstanceName(normalizedName)) {
+            const browser = normalizedName;
+            return {
+                scope: 'default',
+                instanceName: browser,
+                browser,
+                userDataDir: null,
+                createdAt: null,
+                lastConnect: isLastConnectMatch(store.lastConnect, 'default', browser, browser),
+                source: 'argument'
+            };
+        }
+        const persisted = store.instances.find((item)=>item.name === normalizedName);
+        if (!persisted) {
+            throw new Error(`Unknown instance: ${normalizedName}`);
+        }
+        return {
+            scope: 'custom',
+            instanceName: persisted.name,
+            browser: persisted.browser,
+            userDataDir: persisted.userDataDir,
+            createdAt: persisted.createdAt,
+            lastConnect: isLastConnectMatch(store.lastConnect, 'custom', persisted.name, persisted.browser),
+            source: 'argument'
+        };
+    }
+    if (store.lastConnect) {
+        if (store.lastConnect.scope === 'default') {
+            return {
+                scope: 'default',
+                instanceName: store.lastConnect.name,
+                browser: store.lastConnect.browser,
+                userDataDir: null,
+                createdAt: null,
+                lastConnect: true,
+                source: 'last-connect'
+            };
+        }
+        const persisted = store.instances.find((item)=>item.name === store.lastConnect?.name);
+        if (persisted) {
+            return {
+                scope: 'custom',
+                instanceName: persisted.name,
+                browser: persisted.browser,
+                userDataDir: persisted.userDataDir,
+                createdAt: persisted.createdAt,
+                lastConnect: true,
+                source: 'last-connect'
+            };
+        }
+    }
+    if (store.instances.length === 1) {
+        return fromPersistedInstance(store.instances[0], 'single-instance');
+    }
+    throw new Error('No current instance found. Use --instance NAME or connect an instance first.');
+}
+export async function getRednoteStatus(target) {
+    debugLog('status', 'get status start', {
+        target
+    });
+    const spec = findSpec(target.browser);
+    const inspected = await inspectBrowserInstance(spec, undefined, target.scope === 'custom' ? target.userDataDir ?? undefined : undefined);
+    debugLog('status', 'instance inspected', {
+        inspected
+    });
+    let rednote = await getRednoteAccountStatus(target);
+    debugLog('status', 'account status provider result', {
+        rednote
+    });
+    if (rednote.loginStatus === 'unknown') {
+        try {
+            debugLog('status', 'login status unknown, fallback to checkRednoteLogin', {
+                target
+            });
+            const { checkRednoteLogin } = await import('./checkLogin.js');
+            const checked = await checkRednoteLogin(target);
+            debugLog('status', 'fallback checkRednoteLogin succeeded', {
+                checked
+            });
+            rednote = {
+                loginStatus: checked.loginStatus,
+                lastLoginAt: checked.lastLoginAt
+            };
+        } catch (error) {
+            debugLog('status', 'fallback checkRednoteLogin failed', {
+                error: stringifyError(error)
+            });
+            rednote = {
+                loginStatus: 'unknown',
+                lastLoginAt: null
+            };
+        }
+    }
+    return {
+        ok: true,
+        instance: {
+            scope: target.scope,
+            name: target.instanceName,
+            browser: target.browser,
+            source: target.source,
+            status: toInstanceState(inspected),
+            exists: inspected.exists,
+            inUse: inspected.inUse,
+            pid: inspected.pid,
+            remotePort: inspected.remotePort,
+            userDataDir: inspected.userDataDir,
+            createdAt: target.createdAt,
+            lastConnect: target.lastConnect
+        },
+        rednote
+    };
+}
+export async function runStatusCommand(values = {}) {
+    if (values.help) {
+        printStatusHelp();
+        return;
+    }
+    const target = resolveStatusTarget(values.instance);
+    const result = await getRednoteStatus(target);
+    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) {
+        printStatusHelp();
+        return;
+    }
+    await runStatusCommand(values);
+}
+runCli(import.meta.url, main);

package/dist/utils/browser-cli.js

@@ -0,0 +1,155 @@
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
+function printHelp(helpText) {
+    process.stdout.write(helpText);
+}
+export function parseBrowserCliArgs(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        strict: false,
+        options: {
+            browser: {
+                type: 'string'
+            },
+            instance: {
+                type: 'string'
+            },
+            name: {
+                type: 'string'
+            },
+            'executable-path': {
+                type: 'string'
+            },
+            'user-data-dir': {
+                type: 'string'
+            },
+            force: {
+                type: 'boolean'
+            },
+            port: {
+                type: 'string'
+            },
+            timeout: {
+                type: 'string'
+            },
+            'kill-timeout': {
+                type: 'string'
+            },
+            'startup-url': {
+                type: 'string'
+            },
+            help: {
+                type: 'boolean',
+                short: 'h'
+            }
+        }
+    });
+    return {
+        values: values,
+        positionals
+    };
+}
+export function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export function printInitBrowserHelp() {
+    printHelp(`rednote browser
+
+Commands:
+  list
+  create --name NAME [--browser chrome|edge|chromium|brave] [--port 9222]
+  remove --name NAME [--force]
+  connect [--instance NAME] [--browser chrome|edge|chromium|brave] [--user-data-dir PATH] [--force] [--port 9222]
+
+Examples:
+  npx -y @skills-store/rednote browser list
+  npx -y @skills-store/rednote browser create --name seller-main --browser chrome --port 9222
+  npx -y @skills-store/rednote browser remove --name seller-main
+  npx -y @skills-store/rednote browser connect --instance seller-main
+  npx -y @skills-store/rednote browser connect --browser edge --user-data-dir /tmp/edge-profile --port 9223
+`);
+}
+export function printCreateBrowserHelp() {
+    printHelp(`rednote browser create
+
+Usage:
+  npx -y @skills-store/rednote browser create --name NAME [--browser chrome|edge|chromium|brave] [--port 9222]
+  bun ./scripts/browser/create-browser.ts --name NAME [--browser chrome|edge|chromium|brave] [--port 9222]
+`);
+}
+export function printListBrowserHelp() {
+    printHelp(`rednote browser list
+
+Usage:
+  npx -y @skills-store/rednote browser list
+  bun ./scripts/browser/list-browser.ts
+`);
+}
+export function printRemoveBrowserHelp() {
+    printHelp(`rednote browser remove
+
+Usage:
+  npx -y @skills-store/rednote browser remove --name NAME [--force]
+  bun ./scripts/browser/remove-browser.ts --name NAME [--force]
+`);
+}
+export function printConnectBrowserHelp() {
+    printHelp(`rednote browser connect
+
+Usage:
+  npx -y @skills-store/rednote browser connect [--instance NAME] [--browser chrome|edge|chromium|brave] [--user-data-dir PATH] [--force] [--port 9222]
+  bun ./scripts/browser/connect-browser.ts [--instance NAME] [--browser chrome|edge|chromium|brave] [--user-data-dir PATH] [--force] [--port 9222]
+
+Notes:
+  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.
+`);
+}
+export function stringifyError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export function isDebugEnabled() {
+    const value = process.env.REDNOTE_DEBUG?.trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}
+export function debugLog(scope, message, payload) {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    const time = new Date().toISOString();
+    const suffix = payload ? ` ${JSON.stringify(payload)}` : '';
+    process.stderr.write(`[rednote-debug][${time}][${scope}] ${message}${suffix}
+`);
+}
+export function isMainModule(metaUrl) {
+    const entryArg = process.argv[1];
+    if (!entryArg) {
+        return false;
+    }
+    return metaUrl === pathToFileURL(path.resolve(entryArg)).href;
+}
+async function finalizeCliProcess(exitCode) {
+    await new Promise((resolve)=>process.stdout.write('', ()=>resolve()));
+    await new Promise((resolve)=>process.stderr.write('', ()=>resolve()));
+    process.exit(exitCode);
+}
+export function runCli(metaUrl, main) {
+    if (!isMainModule(metaUrl)) {
+        return;
+    }
+    main().then(async ()=>{
+        await finalizeCliProcess(0);
+    }).catch(async (error)=>{
+        process.stderr.write(`${JSON.stringify({
+            ok: false,
+            error: stringifyError(error)
+        }, null, 2)}
+`);
+        await finalizeCliProcess(1);
+    });
+}