@jackwener/opencli 1.4.1 → 1.5.1

package/src/download/index.ts

@@ -8,6 +8,8 @@ import * as path from 'node:path';
 import * as https from 'node:https';
 import * as http from 'node:http';
 import * as os from 'node:os';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { URL } from 'node:url';
 import type { ProgressBar } from './progress.js';
 import { isBinaryInstalled } from '../external.js';
@@ -99,74 +101,84 @@ export async function httpDownload(
       requestHeaders['Cookie'] = cookies;
     }
 
-    // Ensure directory exists
-    const dir = path.dirname(destPath);
-    fs.mkdirSync(dir, { recursive: true });
-
     const tempPath = `${destPath}.tmp`;
-    const file = fs.createWriteStream(tempPath);
+    let settled = false;
 
-    const request = protocol.get(url, { headers: requestHeaders, timeout }, (response) => {
-      // Handle redirects
-      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-        file.close();
-        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
-        if (redirectCount >= maxRedirects) {
-          resolve({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
-          return;
-        }
-        const redirectUrl = resolveRedirectUrl(url, response.headers.location);
-        const originalHost = new URL(url).hostname;
-        const redirectHost = new URL(redirectUrl).hostname;
-        // Do not forward cookies when a redirect crosses host boundaries.
-        const redirectOptions = originalHost === redirectHost
-          ? options
-          : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
-        httpDownload(
-          redirectUrl,
-          destPath,
-          redirectOptions,
-          redirectCount + 1,
-        ).then(resolve);
-        return;
-      }
+    const finish = (result: { success: boolean; size: number; error?: string }) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
 
-      if (response.statusCode !== 200) {
-        file.close();
-        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
-        resolve({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
-        return;
+    const cleanupTempFile = async () => {
+      try {
+        await fs.promises.rm(tempPath, { force: true });
+      } catch {
+        // Ignore cleanup errors so the original failure is preserved.
       }
+    };
 
-      const totalSize = parseInt(response.headers['content-length'] || '0', 10);
-      let received = 0;
-
-      response.on('data', (chunk: Buffer) => {
-        received += chunk.length;
-        if (onProgress) onProgress(received, totalSize);
-      });
+    const request = protocol.get(url, { headers: requestHeaders, timeout }, (response) => {
+      void (async () => {
+        // Handle redirects before creating any file handles.
+        if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          response.resume();
+          if (redirectCount >= maxRedirects) {
+            finish({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
+            return;
+          }
+          const redirectUrl = resolveRedirectUrl(url, response.headers.location);
+          const originalHost = new URL(url).hostname;
+          const redirectHost = new URL(redirectUrl).hostname;
+          const redirectOptions = originalHost === redirectHost
+            ? options
+            : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
+          finish(await httpDownload(
+            redirectUrl,
+            destPath,
+            redirectOptions,
+            redirectCount + 1,
+          ));
+          return;
+        }
 
-      response.pipe(file);
+        if (response.statusCode !== 200) {
+          response.resume();
+          finish({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
+          return;
+        }
 
-      file.on('finish', () => {
-        file.close();
-        // Rename temp file to final destination
-        fs.renameSync(tempPath, destPath);
-        resolve({ success: true, size: received });
-      });
+        const totalSize = parseInt(response.headers['content-length'] || '0', 10);
+        let received = 0;
+        const progressStream = new Transform({
+          transform(chunk, _encoding, callback) {
+            received += chunk.length;
+            if (onProgress) onProgress(received, totalSize);
+            callback(null, chunk);
+          },
+        });
+
+        try {
+          await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+          await pipeline(response, progressStream, fs.createWriteStream(tempPath));
+          await fs.promises.rename(tempPath, destPath);
+          finish({ success: true, size: received });
+        } catch (err) {
+          await cleanupTempFile();
+          finish({ success: false, size: 0, error: getErrorMessage(err) });
+        }
+      })();
     });
 
     request.on('error', (err) => {
-      file.close();
-      if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
-      resolve({ success: false, size: 0, error: err.message });
+      void (async () => {
+        await cleanupTempFile();
+        finish({ success: false, size: 0, error: err.message });
+      })();
     });
 
     request.on('timeout', () => {
-      request.destroy();
-      file.close();
-      if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
-      resolve({ success: false, size: 0, error: 'Timeout' });
+      request.destroy(new Error('Timeout'));
     });
   });
 }

package/src/engine.test.ts

@@ -83,9 +83,15 @@ cli({
 describe('discoverPlugins', () => {
   const testPluginDir = path.join(PLUGINS_DIR, '__test-plugin__');
   const yamlPath = path.join(testPluginDir, 'greeting.yaml');
+  const symlinkTargetDir = path.join(os.tmpdir(), '__test-plugin-symlink-target__');
+  const symlinkPluginDir = path.join(PLUGINS_DIR, '__test-plugin-symlink__');
+  const brokenSymlinkDir = path.join(PLUGINS_DIR, '__test-plugin-broken__');
 
   afterEach(async () => {
     try { await fs.promises.rm(testPluginDir, { recursive: true }); } catch {}
+    try { await fs.promises.rm(symlinkPluginDir, { recursive: true, force: true }); } catch {}
+    try { await fs.promises.rm(symlinkTargetDir, { recursive: true, force: true }); } catch {}
+    try { await fs.promises.rm(brokenSymlinkDir, { recursive: true, force: true }); } catch {}
   });
 
   it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
@@ -118,6 +124,38 @@ columns: [message]
     // discoverPlugins should not throw if ~/.opencli/plugins/ does not exist
     await expect(discoverPlugins()).resolves.not.toThrow();
   });
+
+  it('discovers YAML plugins from symlinked plugin directories', async () => {
+    await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+    await fs.promises.mkdir(symlinkTargetDir, { recursive: true });
+    await fs.promises.writeFile(path.join(symlinkTargetDir, 'hello.yaml'), `
+site: __test-plugin-symlink__
+name: hello
+description: Test plugin greeting via symlink
+strategy: public
+browser: false
+
+pipeline:
+  - evaluate: "() => [{ message: 'hello from symlink plugin' }]"
+
+columns: [message]
+`);
+    await fs.promises.symlink(symlinkTargetDir, symlinkPluginDir, 'dir');
+
+    await discoverPlugins();
+
+    const cmd = getRegistry().get('__test-plugin-symlink__/hello');
+    expect(cmd).toBeDefined();
+    expect(cmd!.description).toBe('Test plugin greeting via symlink');
+  });
+
+  it('skips broken plugin symlinks without throwing', async () => {
+    await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+    await fs.promises.symlink(path.join(os.tmpdir(), '__missing-plugin-target__'), brokenSymlinkDir, 'dir');
+
+    await expect(discoverPlugins()).resolves.not.toThrow();
+    expect(getRegistry().get('__test-plugin-broken__/hello')).toBeUndefined();
+  });
 });
 
 describe('executeCommand', () => {

package/src/errors.ts

@@ -14,109 +14,65 @@ export class CliError extends Error {
 
   constructor(code: string, message: string, hint?: string) {
     super(message);
-    this.name = 'CliError';
+    this.name = new.target.name;
     this.code = code;
     this.hint = hint;
   }
 }
 
-// ── Browser / Connection ────────────────────────────────────────────────────
+export type BrowserConnectKind = 'daemon-not-running' | 'extension-not-connected' | 'command-failed' | 'unknown';
 
 export class BrowserConnectError extends CliError {
-  constructor(message: string, hint?: string) {
+  readonly kind: BrowserConnectKind;
+  constructor(message: string, hint?: string, kind: BrowserConnectKind = 'unknown') {
     super('BROWSER_CONNECT', message, hint);
-    this.name = 'BrowserConnectError';
+    this.kind = kind;
   }
 }
 
-// ── Adapter loading ─────────────────────────────────────────────────────────
-
 export class AdapterLoadError extends CliError {
-  constructor(message: string, hint?: string) {
-    super('ADAPTER_LOAD', message, hint);
-    this.name = 'AdapterLoadError';
-  }
+  constructor(message: string, hint?: string) { super('ADAPTER_LOAD', message, hint); }
 }
 
-// ── Command execution ───────────────────────────────────────────────────────
-
 export class CommandExecutionError extends CliError {
-  constructor(message: string, hint?: string) {
-    super('COMMAND_EXEC', message, hint);
-    this.name = 'CommandExecutionError';
-  }
+  constructor(message: string, hint?: string) { super('COMMAND_EXEC', message, hint); }
 }
 
-// ── Configuration ───────────────────────────────────────────────────────────
-
 export class ConfigError extends CliError {
-  constructor(message: string, hint?: string) {
-    super('CONFIG', message, hint);
-    this.name = 'ConfigError';
-  }
+  constructor(message: string, hint?: string) { super('CONFIG', message, hint); }
 }
 
-// ── Authentication / Login ──────────────────────────────────────────────────
-
 export class AuthRequiredError extends CliError {
   readonly domain: string;
-
   constructor(domain: string, message?: string) {
-    super(
-      'AUTH_REQUIRED',
-      message ?? `Not logged in to ${domain}`,
-      `Please open Chrome and log in to https://${domain}`,
-    );
-    this.name = 'AuthRequiredError';
+    super('AUTH_REQUIRED', message ?? `Not logged in to ${domain}`, `Please open Chrome and log in to https://${domain}`);
     this.domain = domain;
   }
 }
 
-// ── Timeout ─────────────────────────────────────────────────────────────────
-
 export class TimeoutError extends CliError {
-  constructor(label: string, seconds: number) {
+  constructor(label: string, seconds: number, hint?: string) {
     super(
       'TIMEOUT',
       `${label} timed out after ${seconds}s`,
-      'Try again, or increase timeout with OPENCLI_BROWSER_COMMAND_TIMEOUT env var',
+      hint ?? 'Try again, or increase timeout with OPENCLI_BROWSER_COMMAND_TIMEOUT env var',
     );
-    this.name = 'TimeoutError';
   }
 }
 
-// ── Argument validation ─────────────────────────────────────────────────────
-
 export class ArgumentError extends CliError {
-  constructor(message: string, hint?: string) {
-    super('ARGUMENT', message, hint);
-    this.name = 'ArgumentError';
-  }
+  constructor(message: string, hint?: string) { super('ARGUMENT', message, hint); }
 }
 
-// ── Empty result ────────────────────────────────────────────────────────────
-
 export class EmptyResultError extends CliError {
   constructor(command: string, hint?: string) {
-    super(
-      'EMPTY_RESULT',
-      `${command} returned no data`,
-      hint ?? 'The page structure may have changed, or you may need to log in',
-    );
-    this.name = 'EmptyResultError';
+    super('EMPTY_RESULT', `${command} returned no data`, hint ?? 'The page structure may have changed, or you may need to log in');
   }
 }
 
-// ── Selector / DOM ──────────────────────────────────────────────────────────
-
 export class SelectorError extends CliError {
   constructor(selector: string, hint?: string) {
-    super(
-      'SELECTOR',
-      `Could not find element: ${selector}`,
-      hint ?? 'The page UI may have changed. Please report this issue.',
-    );
-    this.name = 'SelectorError';
+    super('SELECTOR', `Could not find element: ${selector}`, hint ?? 'The page UI may have changed. Please report this issue.');
   }
 }
 
@@ -129,10 +85,17 @@ export function getErrorMessage(error: unknown): string {
 
 /** Error code → emoji mapping for CLI output rendering. */
 export const ERROR_ICONS: Record<string, string> = {
-  AUTH_REQUIRED: '🔒',
+  AUTH_REQUIRED:   '🔒',
   BROWSER_CONNECT: '🔌',
-  TIMEOUT: '⏱ ',
-  ARGUMENT: '❌',
-  EMPTY_RESULT: '📭',
-  SELECTOR: '🔍',
+  TIMEOUT:         '⏱ ',
+  ARGUMENT:        '❌',
+  EMPTY_RESULT:    '📭',
+  SELECTOR:        '🔍',
+  COMMAND_EXEC:    '💥',
+  ADAPTER_LOAD:    '📦',
+  NETWORK:         '🌐',
+  API_ERROR:       '🚫',
+  RATE_LIMITED:    '⏳',
+  PAGE_CHANGED:    '🔄',
+  CONFIG:          '⚙️ ',
 };

package/src/execution.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { executeCommand } from './execution.js';
+import { TimeoutError } from './errors.js';
+import { cli, Strategy } from './registry.js';
+import { withTimeoutMs } from './runtime.js';
+
+describe('executeCommand — non-browser timeout', () => {
+  it('applies timeoutSeconds to non-browser commands', async () => {
+    const cmd = cli({
+      site: 'test-execution',
+      name: 'non-browser-timeout',
+      description: 'test non-browser timeout',
+      browser: false,
+      strategy: Strategy.PUBLIC,
+      timeoutSeconds: 0.01,
+      func: () => new Promise(() => {}),
+    });
+
+    // Sentinel timeout at 200ms — if the inner 10ms timeout fires first,
+    // the error will be a TimeoutError with the command label, not 'sentinel'.
+    const error = await withTimeoutMs(executeCommand(cmd, {}), 200, 'sentinel timeout')
+      .catch((err) => err);
+
+    expect(error).toBeInstanceOf(TimeoutError);
+    expect(error).toMatchObject({
+      code: 'TIMEOUT',
+      message: 'test-execution/non-browser-timeout timed out after 0.01s',
+    });
+  });
+
+  it('skips timeout when timeoutSeconds is 0', async () => {
+    const cmd = cli({
+      site: 'test-execution',
+      name: 'non-browser-zero-timeout',
+      description: 'test zero timeout bypasses wrapping',
+      browser: false,
+      strategy: Strategy.PUBLIC,
+      timeoutSeconds: 0,
+      func: () => new Promise(() => {}),
+    });
+
+    // With timeout guard skipped, the sentinel fires instead.
+    await expect(
+      withTimeoutMs(executeCommand(cmd, {}), 50, 'sentinel timeout'),
+    ).rejects.toThrow('sentinel timeout');
+  });
+});

package/src/execution.ts

@@ -10,17 +10,19 @@
  * 6. Lifecycle hooks (onBeforeExecute / onAfterExecute)
  */
 
-import { type CliCommand, type InternalCliCommand, type Arg, Strategy, getRegistry, fullName } from './registry.js';
+import { type CliCommand, type InternalCliCommand, type Arg, type CommandArgs, Strategy, getRegistry, fullName } from './registry.js';
 import type { IPage } from './types.js';
 import { pathToFileURL } from 'node:url';
 import { executePipeline } from './pipeline/index.js';
-import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
+import { AdapterLoadError, ArgumentError, BrowserConnectError, CommandExecutionError, getErrorMessage } from './errors.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook, type HookContext } from './hooks.js';
+import { checkDaemonStatus } from './browser/discover.js';
+import { PKG_VERSION } from './version.js';
+import chalk from 'chalk';
 
 const _loadedModules = new Set<string>();
-type CommandArgs = Record<string, unknown>;
 
 export function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: CommandArgs): CommandArgs {
   const result: CommandArgs = { ...kwargs };
@@ -128,6 +130,23 @@ function ensureRequiredEnv(cmd: CliCommand): void {
   );
 }
 
+/**
+ * Check if the browser is already on the target domain, avoiding redundant navigation.
+ * Returns true if current page hostname matches the pre-nav URL hostname.
+ */
+async function isAlreadyOnDomain(page: IPage, targetUrl: string): Promise<boolean> {
+  if (!page.getCurrentUrl) return false;
+  try {
+    const currentUrl = await page.getCurrentUrl();
+    if (!currentUrl) return false;
+    const currentHost = new URL(currentUrl).hostname;
+    const targetHost = new URL(targetUrl).hostname;
+    return currentHost === targetHost;
+  } catch {
+    return false;
+  }
+}
+
 export async function executeCommand(
   cmd: CliCommand,
   rawKwargs: CommandArgs,
@@ -151,16 +170,45 @@ export async function executeCommand(
   let result: unknown;
   try {
     if (shouldUseBrowserSession(cmd)) {
+      // ── Fail-fast: only when daemon is UP but extension is not connected ──
+      // If daemon is not running, let browserSession() handle auto-start as usual.
+      // We only short-circuit when the daemon confirms the extension is missing —
+      // that's a clear setup gap, not a transient startup state.
+      // Use a short timeout: localhost responds in <50ms when running.
+      // 300ms avoids a full 2s wait on cold-start (daemon not yet running).
+      const status = await checkDaemonStatus({ timeout: 300 });
+      if (status.running && !status.extensionConnected) {
+        throw new BrowserConnectError(
+          'Browser Bridge extension not connected',
+          'Install the Browser Bridge:\n' +
+          '  1. Download: https://github.com/jackwener/opencli/releases\n' +
+          '  2. chrome://extensions → Developer Mode → Load unpacked\n' +
+          '  Then run: opencli doctor',
+        );
+      }
+      // ── Version mismatch: warn but don't block ──
+      if (status.extensionVersion && status.extensionVersion !== PKG_VERSION) {
+        process.stderr.write(
+          chalk.yellow(`⚠  Extension v${status.extensionVersion} ≠ CLI v${PKG_VERSION} — consider updating the extension.\n`)
+        );
+      }
+
       ensureRequiredEnv(cmd);
       const BrowserFactory = getBrowserFactory();
       result = await browserSession(BrowserFactory, async (page) => {
         const preNavUrl = resolvePreNav(cmd);
         if (preNavUrl) {
-          try {
-            await page.goto(preNavUrl);
-            await page.wait(2);
-          } catch (err) {
-            if (debug) console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+          const skip = await isAlreadyOnDomain(page, preNavUrl);
+          if (skip) {
+            if (debug) console.error(`[pre-nav] Already on target domain, skipping navigation`);
+          } else {
+            try {
+              // goto() already includes smart DOM-settle detection (waitForDomStable).
+              // No additional fixed sleep needed.
+              await page.goto(preNavUrl);
+            } catch (err) {
+              if (debug) console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+            }
           }
         }
         return runWithTimeout(runCommand(cmd, page, kwargs, debug), {
@@ -169,7 +217,17 @@ export async function executeCommand(
         });
       }, { workspace: `site:${cmd.site}` });
     } else {
-      result = await runCommand(cmd, null, kwargs, debug);
+      // Non-browser commands: apply timeout only when explicitly configured.
+      const timeout = cmd.timeoutSeconds;
+      if (timeout !== undefined && timeout > 0) {
+        result = await runWithTimeout(runCommand(cmd, null, kwargs, debug), {
+          timeout,
+          label: fullName(cmd),
+          hint: `Increase the adapter's timeoutSeconds setting (currently ${timeout}s)`,
+        });
+      } else {
+        result = await runCommand(cmd, null, kwargs, debug);
+      }
     }
   } catch (err) {
     hookCtx.error = err;

package/src/external.ts

@@ -31,7 +31,10 @@ function getUserRegistryPath(): string {
   return path.join(home, '.opencli', 'external-clis.yaml');
 }
 
+let _cachedExternalClis: ExternalCliConfig[] | null = null;
+
 export function loadExternalClis(): ExternalCliConfig[] {
+  if (_cachedExternalClis) return _cachedExternalClis;
   const configs = new Map<string, ExternalCliConfig>();
 
   // 1. Load built-in
@@ -60,7 +63,8 @@ export function loadExternalClis(): ExternalCliConfig[] {
     log.warn(`Failed to parse user external-clis.yaml: ${getErrorMessage(err)}`);
   }
 
-  return Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+  _cachedExternalClis = Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+  return _cachedExternalClis;
 }
 
 export function isBinaryInstalled(binary: string): boolean {
@@ -237,5 +241,6 @@ export function registerExternalCli(name: string, opts?: RegisterOptions): void
 
   const dump = yaml.dump(items, { indent: 2, sortKeys: true });
   fs.writeFileSync(userPath, dump, 'utf8');
+  _cachedExternalClis = null; // Invalidate cache so next load reflects the change
   console.log(chalk.dim(userPath));
 }

package/src/hooks.ts

@@ -44,6 +44,7 @@ const _hooks: Map<HookName, HookFn[]> =
 
 function addHook(name: HookName, fn: HookFn): void {
   const list = _hooks.get(name) ?? [];
+  if (list.includes(fn)) return;
   list.push(fn);
   _hooks.set(name, list);
 }

package/src/main.ts

@@ -20,15 +20,22 @@ import { discoverClis, discoverPlugins } from './discovery.js';
 import { getCompletions } from './completion.js';
 import { runCli } from './cli.js';
 import { emitHook } from './hooks.js';
+import { registerUpdateNoticeOnExit, checkForUpdateBackground } from './update-check.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
 const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
 
+// Sequential: plugins must run after built-in discovery so they can override built-in commands.
 await discoverClis(BUILTIN_CLIS, USER_CLIS);
 await discoverPlugins();
 
+// Register exit hook: notice appears after command output (same as npm/gh/yarn)
+registerUpdateNoticeOnExit();
+// Kick off background fetch for next run (non-blocking)
+checkForUpdateBackground();
+
 // ── Fast-path: handle --get-completions before commander parses ─────────
 // Usage: opencli --get-completions --cursor <N> [word1 word2 ...]
 const getCompIdx = process.argv.indexOf('--get-completions');

package/src/output.ts

@@ -16,7 +16,9 @@ export interface RenderOptions {
 }
 
 function normalizeRows(data: unknown): Record<string, unknown>[] {
-  return Array.isArray(data) ? data : [data as Record<string, unknown>];
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === 'object') return [data as Record<string, unknown>];
+  return [{ value: data }];
 }
 
 function resolveColumns(rows: Record<string, unknown>[], opts: RenderOptions): string[] {

package/src/pipeline/executor.ts

@@ -7,6 +7,7 @@ import type { IPage } from '../types.js';
 import { getStep, type StepHandler } from './registry.js';
 import { log } from '../logger.js';
 import { ConfigError } from '../errors.js';
+import { BROWSER_ONLY_STEPS } from '../capabilityRouting.js';
 
 export interface PipelineContext {
   args?: Record<string, unknown>;
@@ -15,9 +16,6 @@ export interface PipelineContext {
   stepRetries?: number;
 }
 
-/** Steps that interact with the browser and may fail transiently */
-const BROWSER_STEPS = new Set(['navigate', 'evaluate', 'click', 'type', 'press', 'wait', 'snapshot']);
-
 export async function executePipeline(
   page: IPage | null,
   pipeline: unknown[],
@@ -50,8 +48,8 @@ export async function executePipeline(
     }
   } catch (err) {
     // Attempt cleanup: close automation window on pipeline failure
-    if (page && typeof (page as unknown as Record<string, unknown>).closeWindow === 'function') {
-      try { await (page as unknown as { closeWindow: () => Promise<void> }).closeWindow(); } catch { /* ignore */ }
+    if (page?.closeWindow) {
+      try { await page.closeWindow(); } catch { /* ignore */ }
     }
     throw err;
   }
@@ -67,7 +65,7 @@ async function executeStepWithRetry(
   op: string,
   configRetries?: number,
 ): Promise<unknown> {
-  const maxRetries = configRetries ?? (BROWSER_STEPS.has(op) ? 2 : 0);
+  const maxRetries = configRetries ?? (BROWSER_ONLY_STEPS.has(op) ? 2 : 0);
 
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {