@skills-store/rednote 0.1.0

package/scripts/rednote/status.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env -S node --experimental-strip-types
+
+import { parseArgs } from 'node:util';
+import {
+  findSpec,
+  inspectBrowserInstance,
+  isDefaultInstanceName,
+  isLastConnectMatch,
+  readInstanceStore,
+  type BrowserInstanceInfo,
+  type BrowserType,
+  type PersistedInstance,
+} from '../utils/browser-core.ts';
+import { debugLog, printJson, runCli, stringifyError } from '../utils/browser-cli.ts';
+
+export type RednoteLoginStatus = 'logged-in' | 'logged-out' | 'unknown';
+
+export type RednoteAccountStatus = {
+  loginStatus: RednoteLoginStatus;
+  lastLoginAt: string | null;
+};
+
+export type RednoteStatusSource = 'argument' | 'last-connect' | 'single-instance';
+
+export type RednoteStatusTarget = {
+  scope: 'default' | 'custom';
+  instanceName: string;
+  browser: BrowserType;
+  userDataDir: string | null;
+  createdAt: string | null;
+  lastConnect: boolean;
+  source: RednoteStatusSource;
+};
+
+export type ResolveRednoteAccountStatusContext = RednoteStatusTarget;
+
+export type RednoteAccountStatusProvider = (
+  context: ResolveRednoteAccountStatusContext,
+) => Promise<RednoteAccountStatus> | RednoteAccountStatus;
+
+export type RednoteInstanceState = 'running' | 'stopped' | 'missing' | 'stale-lock';
+
+export type RednoteStatusResult = {
+  ok: true;
+  instance: {
+    scope: 'default' | 'custom';
+    name: string;
+    browser: BrowserType;
+    source: RednoteStatusSource;
+    status: RednoteInstanceState;
+    exists: boolean;
+    inUse: boolean;
+    pid: number | null;
+    remotePort: number | null;
+    userDataDir: string;
+    createdAt: string | null;
+    lastConnect: boolean;
+  };
+  rednote: RednoteAccountStatus;
+};
+
+export type StatusCliValues = {
+  instance?: string;
+  help?: boolean;
+};
+
+let rednoteAccountStatusProvider: RednoteAccountStatusProvider = async () => ({
+  loginStatus: 'unknown',
+  lastLoginAt: null,
+});
+
+export function registerRednoteAccountStatusProvider(provider: RednoteAccountStatusProvider) {
+  rednoteAccountStatusProvider = provider;
+}
+
+export async function getRednoteAccountStatus(context: ResolveRednoteAccountStatusContext) {
+  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: BrowserInstanceInfo): RednoteInstanceState {
+  if (instance.staleLock) {
+    return 'stale-lock';
+  }
+
+  if (instance.inUse) {
+    return 'running';
+  }
+
+  if (instance.exists) {
+    return 'stopped';
+  }
+
+  return 'missing';
+}
+
+function fromPersistedInstance(
+  instance: PersistedInstance,
+  source: RednoteStatusSource,
+): RednoteStatusTarget {
+  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?: string): RednoteStatusTarget {
+  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 as BrowserType;
+      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: RednoteStatusTarget): Promise<RednoteStatusResult> {
+  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.ts');
+      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: StatusCliValues = {}) {
+  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/scripts/utils/browser-cli.ts

@@ -0,0 +1,176 @@
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
+
+export type BrowserCliValues = {
+  browser?: 'chrome' | 'edge' | 'chromium' | 'brave';
+  instance?: string;
+  name?: string;
+  'executable-path'?: string;
+  'user-data-dir'?: string;
+  force?: boolean;
+  port?: string;
+  timeout?: string;
+  'kill-timeout'?: string;
+  'startup-url'?: string;
+  help?: boolean;
+};
+
+export type BrowserCliArgs = {
+  values: BrowserCliValues;
+  positionals: string[];
+};
+
+function printHelp(helpText: string) {
+  process.stdout.write(helpText);
+}
+
+export function parseBrowserCliArgs(argv: string[]): BrowserCliArgs {
+  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 as BrowserCliValues,
+    positionals,
+  };
+}
+
+export function printJson(value: unknown) {
+  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: unknown) {
+  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: string, message: string, payload?: Record<string, unknown>) {
+  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: string) {
+  const entryArg = process.argv[1];
+  if (!entryArg) {
+    return false;
+  }
+  return metaUrl === pathToFileURL(path.resolve(entryArg)).href;
+}
+
+async function finalizeCliProcess(exitCode: number) {
+  await new Promise<void>((resolve) => process.stdout.write('', () => resolve()));
+  await new Promise<void>((resolve) => process.stderr.write('', () => resolve()));
+  process.exit(exitCode);
+}
+
+export function runCli(metaUrl: string, main: () => Promise<void>) {
+  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);
+    });
+}