@jackwener/opencli 1.6.2 → 1.6.4

package/src/tui.ts

@@ -1,237 +0,0 @@
-/**
- * tui.ts — Zero-dependency interactive TUI components
- *
- * Uses raw stdin mode + ANSI escape codes for interactive prompts.
- */
-import chalk from 'chalk';
-import { EXIT_CODES } from './errors.js';
-
-export interface CheckboxItem {
-  label: string;
-  value: string;
-  checked: boolean;
-  /** Optional status to display after the label */
-  status?: string;
-  statusColor?: 'green' | 'yellow' | 'red' | 'dim';
-}
-
-/**
- * Interactive multi-select checkbox prompt.
- *
- * Controls:
- *   ↑/↓ or j/k  — navigate
- *   Space        — toggle selection
- *   a            — toggle all
- *   Enter        — confirm
- *   q/Esc        — cancel (returns empty)
- */
-export async function checkboxPrompt(
-  items: CheckboxItem[],
-  opts: { title?: string; hint?: string } = {},
-): Promise<string[]> {
-  if (items.length === 0) return [];
-
-  const { stdin, stdout } = process;
-  if (!stdin.isTTY) {
-    // Non-interactive: return all checked items
-    return items.filter(i => i.checked).map(i => i.value);
-  }
-
-  let cursor = 0;
-  const state = items.map(i => ({ ...i }));
-
-  function colorStatus(status: string | undefined, color: CheckboxItem['statusColor']): string {
-    if (!status) return '';
-    switch (color) {
-      case 'green': return chalk.green(status);
-      case 'yellow': return chalk.yellow(status);
-      case 'red': return chalk.red(status);
-      case 'dim': return chalk.dim(status);
-      default: return chalk.dim(status);
-    }
-  }
-
-  function render() {
-    // Move cursor to start and clear
-    let out = '';
-
-    if (opts.title) {
-      out += `\n${chalk.bold(opts.title)}\n\n`;
-    }
-
-    for (let i = 0; i < state.length; i++) {
-      const item = state[i];
-      const pointer = i === cursor ? chalk.cyan('❯') : ' ';
-      const checkbox = item.checked ? chalk.green('◉') : chalk.dim('○');
-      const label = i === cursor ? chalk.bold(item.label) : item.label;
-      const status = colorStatus(item.status, item.statusColor);
-      out += `  ${pointer} ${checkbox} ${label}${status ? `  ${status}` : ''}\n`;
-    }
-
-    out += `\n  ${chalk.dim('↑↓ navigate  ·  Space toggle  ·  a all  ·  Enter confirm  ·  q cancel')}\n`;
-
-    return out;
-  }
-
-  return new Promise<string[]>((resolve) => {
-    const wasRaw = stdin.isRaw;
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdout.write('\x1b[?25l'); // Hide cursor
-
-    let firstDraw = true;
-
-    function draw() {
-      // Clear previous render (skip on first draw)
-      if (!firstDraw) {
-        const lines = render().split('\n').length;
-        stdout.write(`\x1b[${lines}A\x1b[J`);
-      }
-      firstDraw = false;
-      stdout.write(render());
-    }
-
-    function cleanup() {
-      stdin.setRawMode(wasRaw ?? false);
-      stdin.pause();
-      stdin.removeListener('data', onData);
-      // Clear the TUI and restore cursor
-      const lines = render().split('\n').length;
-      stdout.write(`\x1b[${lines}A\x1b[J`);
-      stdout.write('\x1b[?25h'); // Show cursor
-    }
-
-    function onData(data: Buffer) {
-      const key = data.toString();
-
-      // Arrow up / k
-      if (key === '\x1b[A' || key === 'k') {
-        cursor = (cursor - 1 + state.length) % state.length;
-        draw();
-        return;
-      }
-
-      // Arrow down / j
-      if (key === '\x1b[B' || key === 'j') {
-        cursor = (cursor + 1) % state.length;
-        draw();
-        return;
-      }
-
-      // Space — toggle
-      if (key === ' ') {
-        state[cursor].checked = !state[cursor].checked;
-        draw();
-        return;
-      }
-
-      // Tab — toggle and move down
-      if (key === '\t') {
-        state[cursor].checked = !state[cursor].checked;
-        cursor = (cursor + 1) % state.length;
-        draw();
-        return;
-      }
-
-      // 'a' — toggle all
-      if (key === 'a') {
-        const allChecked = state.every(i => i.checked);
-        for (const item of state) item.checked = !allChecked;
-        draw();
-        return;
-      }
-
-      // Enter — confirm
-      if (key === '\r' || key === '\n') {
-        cleanup();
-        const selected = state.filter(i => i.checked).map(i => i.value);
-        // Show summary
-        stdout.write(`  ${chalk.green('✓')} ${chalk.bold(`${selected.length} file(s) selected`)}\n\n`);
-        resolve(selected);
-        return;
-      }
-
-      // q / Esc — cancel
-      if (key === 'q' || key === '\x1b') {
-        cleanup();
-        stdout.write(`  ${chalk.yellow('✗')} ${chalk.dim('Cancelled')}\n\n`);
-        resolve([]);
-        return;
-      }
-
-      // Ctrl+C — exit process
-      if (key === '\x03') {
-        cleanup();
-        process.exit(EXIT_CODES.INTERRUPTED);
-      }
-    }
-
-    stdin.on('data', onData);
-    draw();
-  });
-}
-
-/**
- * Simple yes/no confirmation prompt.
- *
- * In non-TTY environments, returns `defaultYes` (defaults to true) without blocking.
- * In TTY, waits for a single keypress: y/Enter → true, n/Esc/q → false.
- */
-export async function confirmPrompt(
-  message: string,
-  defaultYes: boolean = true,
-): Promise<boolean> {
-  const { stdin, stdout } = process;
-  if (!stdin.isTTY) return defaultYes;
-
-  const hint = defaultYes ? '[Y/n]' : '[y/N]';
-  stdout.write(`  ${message} ${chalk.dim(hint)} `);
-
-  return new Promise<boolean>((resolve) => {
-    const wasRaw = stdin.isRaw;
-    stdin.setRawMode(true);
-    stdin.resume();
-
-    function cleanup() {
-      stdin.setRawMode(wasRaw ?? false);
-      stdin.pause();
-      stdin.removeListener('data', onData);
-      stdout.write('\n');
-    }
-
-    function onData(data: Buffer) {
-      const key = data.toString();
-
-      // Ctrl+C
-      if (key === '\x03') {
-        cleanup();
-        process.exit(EXIT_CODES.INTERRUPTED);
-      }
-
-      // Enter — use default
-      if (key === '\r' || key === '\n') {
-        cleanup();
-        resolve(defaultYes);
-        return;
-      }
-
-      // y/Y — yes
-      if (key === 'y' || key === 'Y') {
-        cleanup();
-        resolve(true);
-        return;
-      }
-
-      // n/N/q/Esc — no
-      if (key === 'n' || key === 'N' || key === 'q' || key === '\x1b') {
-        cleanup();
-        resolve(false);
-        return;
-      }
-
-      // Ignore other keys
-    }
-
-    stdin.on('data', onData);
-  });
-}

package/src/types.ts

@@ -1,95 +0,0 @@
-/**
- * Page interface: type-safe abstraction over browser page.
- *
- * All pipeline steps and CLI adapters should use this interface
- * instead of `any` for browser interactions.
- */
-
-export interface BrowserCookie {
-  name: string;
-  value: string;
-  domain: string;
-  path?: string;
-  secure?: boolean;
-  httpOnly?: boolean;
-  expirationDate?: number;
-}
-
-export interface SnapshotOptions {
-  interactive?: boolean;
-  compact?: boolean;
-  maxDepth?: number;
-  raw?: boolean;
-  viewportExpand?: number;
-  maxTextLength?: number;
-}
-
-export interface WaitOptions {
-  text?: string;
-  selector?: string;   // wait until document.querySelector(selector) matches
-  time?: number;
-  timeout?: number;
-}
-
-export interface ScreenshotOptions {
-  format?: 'png' | 'jpeg';
-  quality?: number;
-  fullPage?: boolean;
-  path?: string;
-}
-
-export interface BrowserSessionInfo {
-  workspace?: string;
-  connected?: boolean;
-  [key: string]: unknown;
-}
-
-export interface IPage {
-  goto(url: string, options?: { waitUntil?: 'load' | 'none'; settleMs?: number }): Promise<void>;
-  evaluate(js: string): Promise<any>;
-  getCookies(opts?: { domain?: string; url?: string }): Promise<BrowserCookie[]>;
-  snapshot(opts?: SnapshotOptions): Promise<any>;
-  click(ref: string): Promise<void>;
-  typeText(ref: string, text: string): Promise<void>;
-  pressKey(key: string): Promise<void>;
-  scrollTo(ref: string): Promise<any>;
-  getFormState(): Promise<any>;
-  wait(options: number | WaitOptions): Promise<void>;
-  tabs(): Promise<any>;
-  closeTab?(index?: number): Promise<void>;
-  newTab?(): Promise<void>;
-  selectTab(index: number): Promise<void>;
-  networkRequests(includeStatic?: boolean): Promise<any>;
-  consoleMessages(level?: string): Promise<any>;
-  scroll(direction?: string, amount?: number): Promise<void>;
-  autoScroll(options?: { times?: number; delayMs?: number }): Promise<void>;
-  installInterceptor(pattern: string): Promise<void>;
-  getInterceptedRequests(): Promise<any[]>;
-  waitForCapture(timeout?: number): Promise<void>;
-  screenshot(options?: ScreenshotOptions): Promise<string>;
-  startNetworkCapture?(pattern?: string): Promise<void>;
-  readNetworkCapture?(): Promise<unknown[]>;
-  /**
-   * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
-   * Chrome reads the files directly — no base64 encoding or payload size limits.
-   */
-  setFileInput?(files: string[], selector?: string): Promise<void>;
-  /**
-   * Insert text via native CDP Input.insertText into the currently focused element.
-   * Useful for rich editors that ignore synthetic DOM value/text mutations.
-   */
-  insertText?(text: string): Promise<void>;
-  closeWindow?(): Promise<void>;
-  /** Returns the current page URL, or null if unavailable. */
-  getCurrentUrl?(): Promise<string | null>;
-  /** Returns the active tab ID, or undefined if not yet resolved. */
-  getActiveTabId?(): number | undefined;
-  /** Send a raw CDP command via chrome.debugger passthrough. */
-  cdp?(method: string, params?: Record<string, unknown>): Promise<unknown>;
-  /** Click at native coordinates via CDP Input.dispatchMouseEvent. */
-  nativeClick?(x: number, y: number): Promise<void>;
-  /** Type text via CDP Input.insertText. */
-  nativeType?(text: string): Promise<void>;
-  /** Press a key via CDP Input.dispatchKeyEvent. */
-  nativeKeyPress?(key: string, modifiers?: string[]): Promise<void>;
-}

package/src/update-check.ts

@@ -1,114 +0,0 @@
-/**
- * Non-blocking update checker.
- *
- * Pattern: register exit-hook + kick-off-background-fetch
- * - On startup: kick off background fetch (non-blocking)
- * - On process exit: read cache, print notice if newer version exists
- * - Check interval: 24 hours
- * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
- * - Never delays or blocks the CLI command
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import chalk from 'chalk';
-import { PKG_VERSION } from './version.js';
-
-const CACHE_DIR = path.join(os.homedir(), '.opencli');
-const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24h
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@jackwener/opencli/latest';
-
-interface UpdateCache {
-  lastCheck: number;
-  latestVersion: string;
-}
-
-// Read cache once at module load — shared by both exported functions
-const _cache: UpdateCache | null = (() => {
-  try {
-    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8')) as UpdateCache;
-  } catch {
-    return null;
-  }
-})();
-
-function writeCache(latestVersion: string): void {
-  try {
-    fs.mkdirSync(CACHE_DIR, { recursive: true });
-    fs.writeFileSync(CACHE_FILE, JSON.stringify({ lastCheck: Date.now(), latestVersion }), 'utf-8');
-  } catch {
-    // Best-effort; never fail
-  }
-}
-
-/** Compare semver strings. Returns true if `a` is strictly newer than `b`. */
-function isNewer(a: string, b: string): boolean {
-  const parse = (v: string) => v.replace(/^v/, '').split('-')[0].split('.').map(Number);
-  const pa = parse(a);
-  const pb = parse(b);
-  if (pa.some(isNaN) || pb.some(isNaN)) return false;
-  const [aMaj, aMin, aPat] = pa;
-  const [bMaj, bMin, bPat] = pb;
-  if (aMaj !== bMaj) return aMaj > bMaj;
-  if (aMin !== bMin) return aMin > bMin;
-  return aPat > bPat;
-}
-
-function isCI(): boolean {
-  return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION);
-}
-
-/**
- * Register a process exit hook that prints an update notice if a newer
- * version was found on the last background check.
- * Notice appears after command output — same pattern as npm/gh/yarn.
- * Skipped during --get-completions to avoid polluting shell completion output.
- */
-export function registerUpdateNoticeOnExit(): void {
-  if (isCI()) return;
-  if (process.argv.includes('--get-completions')) return;
-
-  process.on('exit', (code) => {
-    if (code !== 0) return; // Don't show update notice on error exit
-    if (!_cache) return;
-    if (!isNewer(_cache.latestVersion, PKG_VERSION)) return;
-    try {
-      process.stderr.write(
-        chalk.yellow(`\n  Update available: v${PKG_VERSION} → v${_cache.latestVersion}\n`) +
-        chalk.dim(`  Run: npm install -g @jackwener/opencli\n\n`),
-      );
-    } catch {
-      // Ignore broken pipe (stderr closed before process exits)
-    }
-  });
-}
-
-/**
- * Kick off a background fetch to npm registry. Writes to cache for next run.
- * Fully non-blocking — never awaited.
- */
-export function checkForUpdateBackground(): void {
-  if (isCI()) return;
-  if (_cache && Date.now() - _cache.lastCheck < CHECK_INTERVAL_MS) return;
-
-  void (async () => {
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 3000);
-      const res = await fetch(NPM_REGISTRY_URL, {
-        signal: controller.signal,
-        headers: { 'User-Agent': `opencli/${PKG_VERSION}` },
-      });
-      clearTimeout(timer);
-      if (!res.ok) return;
-      const data = await res.json() as { version?: string };
-      if (typeof data.version === 'string') {
-        writeCache(data.version);
-      }
-    } catch {
-      // Network error: silently skip, try again next run
-    }
-  })();
-}

package/src/utils.ts

@@ -1,44 +0,0 @@
-/**
- * Shared utility functions used across the codebase.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-/** Type guard: checks if a value is a non-null, non-array object. */
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/** Simple async concurrency limiter. */
-export async function mapConcurrent<T, R>(
-  items: T[],
-  limit: number,
-  fn: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-  const results: R[] = new Array(items.length);
-  let index = 0;
-
-  async function worker() {
-    while (index < items.length) {
-      const i = index++;
-      results[i] = await fn(items[i], i);
-    }
-  }
-
-  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
-}
-
-/** Pause for the given number of milliseconds. */
-export function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/** Save a base64-encoded string to a file, creating parent directories as needed. */
-export async function saveBase64ToFile(base64: string, filePath: string): Promise<void> {
-  const dir = path.dirname(filePath);
-  await fs.promises.mkdir(dir, { recursive: true });
-  await fs.promises.writeFile(filePath, Buffer.from(base64, 'base64'));
-}

package/src/validate.ts

@@ -1,103 +0,0 @@
-/** Validate CLI definitions. */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import yaml from 'js-yaml';
-import { getErrorMessage } from './errors.js';
-
-/** All recognized pipeline step names */
-const KNOWN_STEP_NAMES = new Set([
-  'navigate', 'click', 'type', 'wait', 'press', 'snapshot',
-  'fetch', 'evaluate',
-  'select', 'map', 'filter', 'sort', 'limit',
-  'intercept', 'tap', 'download',
-]);
-
-export interface FileValidationResult {
-  path: string;
-  errors: string[];
-  warnings: string[];
-}
-
-export interface ValidationReport {
-  ok: boolean;
-  results: FileValidationResult[];
-  errors: number;
-  warnings: number;
-  files: number;
-}
-
-interface ValidatedYamlCliDefinition {
-  site?: string;
-  name?: string;
-  pipeline?: unknown[];
-  columns?: unknown[];
-  args?: Record<string, unknown>;
-}
-
-import { isRecord } from './utils.js';
-
-
-export function validateClisWithTarget(dirs: string[], target?: string): ValidationReport {
-  const results: FileValidationResult[] = [];
-  let errors = 0; let warnings = 0; let files = 0;
-  for (const dir of dirs) {
-    if (!fs.existsSync(dir)) continue;
-    for (const site of fs.readdirSync(dir)) {
-      if (target && site !== target && !target.startsWith(site + '/')) continue;
-      const siteDir = path.join(dir, site);
-      if (!fs.statSync(siteDir).isDirectory()) continue;
-      for (const file of fs.readdirSync(siteDir)) {
-        if (!file.endsWith('.yaml') && !file.endsWith('.yml')) continue;
-        if (target && target.includes('/') && !target.endsWith(file.replace(/\.(yaml|yml)$/, ''))) continue;
-        files++;
-        const filePath = path.join(siteDir, file);
-        const r = validateYamlFile(filePath);
-        results.push(r);
-        errors += r.errors.length;
-        warnings += r.warnings.length;
-      }
-    }
-  }
-  return { ok: errors === 0, results, errors, warnings, files };
-}
-
-function validateYamlFile(filePath: string): FileValidationResult {
-  const errors: string[] = []; const warnings: string[] = [];
-  try {
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const def = yaml.load(raw) as ValidatedYamlCliDefinition | null;
-    if (!isRecord(def)) { errors.push('Not a valid YAML object'); return { path: filePath, errors, warnings }; }
-    if (!def.site) errors.push('Missing "site"');
-    if (!def.name) errors.push('Missing "name"');
-    if (def.pipeline && !Array.isArray(def.pipeline)) errors.push('"pipeline" must be an array');
-    if (def.columns && !Array.isArray(def.columns)) errors.push('"columns" must be an array');
-    if (def.args && typeof def.args !== 'object') errors.push('"args" must be an object');
-    // Validate pipeline step names (catch typos like 'navaigate')
-    if (Array.isArray(def.pipeline)) {
-      for (let i = 0; i < def.pipeline.length; i++) {
-        const step = def.pipeline[i];
-        if (step && typeof step === 'object') {
-          const stepKeys = Object.keys(step);
-          for (const key of stepKeys) {
-            if (!KNOWN_STEP_NAMES.has(key)) {
-              warnings.push(`Pipeline step ${i}: unknown step name "${key}" (did you mean one of: ${[...KNOWN_STEP_NAMES].join(', ')}?)`);
-            }
-          }
-        }
-      }
-    }
-  } catch (e) { errors.push(`YAML parse error: ${getErrorMessage(e)}`); }
-  return { path: filePath, errors, warnings };
-}
-
-export function renderValidationReport(report: ValidationReport): string {
-  const lines = [`opencli validate: ${report.ok ? 'PASS' : 'FAIL'}`, `Checked ${report.results.length} CLI(s) in ${report.files} file(s)`, `Errors: ${report.errors}  Warnings: ${report.warnings}`];
-  for (const r of report.results) {
-    if (r.errors.length > 0 || r.warnings.length > 0) {
-      lines.push(`\n${r.path}:`);
-      for (const e of r.errors) lines.push(`  ❌ ${e}`);
-      for (const w of r.warnings) lines.push(`  ⚠️  ${w}`);
-    }
-  }
-  return lines.join('\n');
-}

package/src/verify.ts

@@ -1,93 +0,0 @@
-/**
- * Verification: runs validation and optional smoke test.
- *
- * The smoke test is intentionally kept as a stub — full browser-based
- * smoke testing requires a running browser session and is better suited
- * to the `opencli test` command or CI pipelines.
- */
-
-import { validateClisWithTarget, renderValidationReport, type ValidationReport } from './validate.js';
-import { spawn } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-export interface VerifyOptions {
-  builtinClis: string;
-  userClis: string;
-  target?: string;
-  smoke?: boolean;
-}
-
-export interface VerifyReport {
-  ok: boolean;
-  validation: ValidationReport;
-  smoke: null | {
-    requested: boolean;
-    executed: boolean;
-    ok: boolean;
-    summary: string;
-  };
-}
-
-export async function verifyClis(opts: VerifyOptions): Promise<VerifyReport> {
-  const report = validateClisWithTarget([opts.builtinClis, opts.userClis], opts.target);
-  let smoke: VerifyReport['smoke'] = null;
-  if (opts.smoke) {
-    smoke = await runSmokeTests(opts.builtinClis);
-  }
-  return { ok: report.ok && (smoke?.ok ?? true), validation: report, smoke };
-}
-
-export function renderVerifyReport(report: VerifyReport): string {
-  const base = renderValidationReport(report.validation);
-  if (!report.smoke) return base;
-  const status = report.smoke.ok ? 'PASS' : 'FAIL';
-  const mode = report.smoke.executed ? 'executed' : 'skipped';
-  return `${base}\nSmoke: ${status} (${mode}) — ${report.smoke.summary}`;
-}
-
-async function runSmokeTests(builtinClis: string): Promise<NonNullable<VerifyReport['smoke']>> {
-  const projectRoot = path.resolve(builtinClis, '..', '..');
-  const smokeDir = path.join(projectRoot, 'tests', 'smoke');
-
-  if (!fs.existsSync(smokeDir)) {
-    return {
-      requested: true,
-      executed: false,
-      ok: false,
-      summary: 'Smoke tests are unavailable in this package/environment.',
-    };
-  }
-
-  const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-  return new Promise((resolve) => {
-    const child = spawn(npx, ['vitest', 'run', 'tests/smoke/', '--reporter=dot'], {
-      cwd: projectRoot,
-      env: { ...process.env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let stderr = '';
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
-    });
-
-    child.on('error', (error) => {
-      resolve({
-        requested: true,
-        executed: false,
-        ok: false,
-        summary: `Failed to start smoke tests: ${error.message}`,
-      });
-    });
-
-    child.on('close', (code) => {
-      resolve({
-        requested: true,
-        executed: true,
-        ok: code === 0,
-        summary: code === 0 ? 'tests/smoke passed' : (stderr.trim() || `vitest exited with code ${code}`),
-      });
-    });
-  });
-}