@jackwener/opencli 1.1.1 → 1.2.1

package/src/execution.ts

@@ -11,19 +11,25 @@
 
 import { type CliCommand, type InternalCliCommand, type Arg, Strategy, getRegistry, fullName } from './registry.js';
 import type { IPage } from './types.js';
-import { executePipeline } from './pipeline.js';
+import { pathToFileURL } from 'node:url';
+import { executePipeline } from './pipeline/index.js';
 import { AdapterLoadError } from './errors.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 
 /** Set of TS module paths that have been loaded */
 const _loadedModules = new Set<string>();
+type CommandArgs = Record<string, unknown>;
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
 
 /**
  * Validates and coerces arguments based on the command's Arg definitions.
  */
-export function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: Record<string, any>): Record<string, any> {
-  const result: Record<string, any> = { ...kwargs };
+export function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: CommandArgs): CommandArgs {
+  const result: CommandArgs = { ...kwargs };
 
   for (const argDef of cmdArgs) {
     const val = result[argDef.name];
@@ -72,20 +78,20 @@ export function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: Record<string, any
 async function runCommand(
   cmd: CliCommand,
   page: IPage | null,
-  kwargs: Record<string, any>,
+  kwargs: CommandArgs,
   debug: boolean,
-): Promise<any> {
+): Promise<unknown> {
   // Lazy-load TS module on first execution (manifest fast-path)
   const internal = cmd as InternalCliCommand;
   if (internal._lazy && internal._modulePath) {
     const modulePath = internal._modulePath;
     if (!_loadedModules.has(modulePath)) {
       try {
-        await import(`file://${modulePath}`);
+        await import(pathToFileURL(modulePath).href);
         _loadedModules.add(modulePath);
-      } catch (err: any) {
+      } catch (err) {
         throw new AdapterLoadError(
-          `Failed to load adapter module ${modulePath}: ${err.message}`,
+          `Failed to load adapter module ${modulePath}: ${getErrorMessage(err)}`,
           'Check that the adapter file exists and has no syntax errors.',
         );
       }
@@ -101,6 +107,24 @@ async function runCommand(
   throw new Error(`Command ${fullName(cmd)} has no func or pipeline`);
 }
 
+/**
+ * Resolve the pre-navigation URL for a command, or null to skip.
+ *
+ * COOKIE/HEADER strategies need the browser on the target domain so
+ * `fetch(url, { credentials: 'include' })` carries cookies.
+ * Adapters that handle their own navigation set `navigateBefore: false`.
+ */
+function resolvePreNav(cmd: CliCommand): string | null {
+  if (cmd.navigateBefore === false) return null;
+  if (typeof cmd.navigateBefore === 'string') return cmd.navigateBefore;
+
+  // Default: pre-navigate for COOKIE/HEADER strategies with a domain
+  if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
+    return `https://${cmd.domain}`;
+  }
+  return null;
+}
+
 /**
  * Execute a CLI command. Automatically manages browser sessions when needed.
  *
@@ -109,22 +133,24 @@ async function runCommand(
  */
 export async function executeCommand(
   cmd: CliCommand,
-  rawKwargs: Record<string, any>,
+  rawKwargs: CommandArgs,
   debug: boolean = false,
-): Promise<any> {
-  let kwargs: Record<string, any>;
+): Promise<unknown> {
+  let kwargs: CommandArgs;
   try {
     kwargs = coerceAndValidateArgs(cmd.args, rawKwargs);
-  } catch (err: any) {
-    throw new Error(`[Argument Validation Error]\n${err.message}`);
+  } catch (err) {
+    throw new Error(`[Argument Validation Error]\n${getErrorMessage(err)}`);
   }
 
   if (shouldUseBrowserSession(cmd)) {
     const BrowserFactory = getBrowserFactory();
     return browserSession(BrowserFactory, async (page) => {
-      // Cookie/header strategies require same-origin context for credentialed fetch.
-      if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
-        try { await page.goto(`https://${cmd.domain}`); await page.wait(2); } catch {}
+      // Pre-navigate to target domain for cookie/header context if needed.
+      // Each adapter controls this via `navigateBefore` (see CliCommand docs).
+      const preNavUrl = resolvePreNav(cmd);
+      if (preNavUrl) {
+        try { await page.goto(preNavUrl); await page.wait(2); } catch {}
       }
       return runWithTimeout(runCommand(cmd, page, kwargs, debug), {
         timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT,

package/src/explore.ts

@@ -9,10 +9,12 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { DEFAULT_BROWSER_EXPLORE_TIMEOUT, browserSession, runWithTimeout } from './runtime.js';
+import type { IBrowserFactory } from './runtime.js';
 import { VOLATILE_PARAMS, SEARCH_PARAMS, PAGINATION_PARAMS, LIMIT_PARAMS, FIELD_ROLES } from './constants.js';
 import { detectFramework } from './scripts/framework.js';
 import { discoverStores } from './scripts/store.js';
 import { interactFuzz } from './scripts/interact.js';
+import type { IPage } from './types.js';
 
 // ── Site name detection ────────────────────────────────────────────────────
 
@@ -68,7 +70,61 @@ interface InferredCapability {
   name: string; description: string; strategy: string; confidence: number;
   endpoint: string; itemPath: string | null;
   recommendedColumns: string[];
-  recommendedArgs: Array<{ name: string; type: string; required: boolean; default?: any }>;
+  recommendedArgs: Array<{ name: string; type: string; required: boolean; default?: unknown }>;
+  storeHint?: { store: string; action: string };
+}
+
+export interface ExploreManifest {
+  site: string;
+  target_url: string;
+  final_url: string;
+  title: string;
+  framework: Record<string, boolean>;
+  stores: Array<{ type: DiscoveredStore['type']; id: string; actions: string[] }>;
+  top_strategy: string;
+  explored_at?: string;
+}
+
+export interface ExploreAuthSummary {
+  top_strategy: string;
+  indicators: string[];
+  framework: Record<string, boolean>;
+}
+
+export interface ExploreEndpointArtifact {
+  pattern: string;
+  method: string;
+  url: string;
+  status: number | null;
+  contentType: string;
+  score: number;
+  queryParams: string[];
+  itemPath: string | null;
+  itemCount: number;
+  detectedFields: Record<string, string>;
+  authIndicators: string[];
+}
+
+export interface ExploreResult {
+  site: string;
+  target_url: string;
+  final_url: string;
+  title: string;
+  framework: Record<string, boolean>;
+  stores: DiscoveredStore[];
+  top_strategy: string;
+  endpoint_count: number;
+  api_endpoint_count: number;
+  capabilities: InferredCapability[];
+  auth_indicators: string[];
+  out_dir: string;
+}
+
+export interface ExploreBundle {
+  manifest: ExploreManifest;
+  endpoints: ExploreEndpointArtifact[];
+  capabilities: InferredCapability[];
+  auth: ExploreAuthSummary;
 }
 
 /**
@@ -167,7 +223,11 @@ function flattenFields(obj: unknown, prefix: string, maxDepth: number): string[]
   return names;
 }
 
-function scoreEndpoint(ep: { contentType: string; responseAnalysis: any; pattern: string; status: number | null; hasSearchParam: boolean; hasPaginationParam: boolean; hasLimitParam: boolean }): number {
+function isBooleanRecord(value: unknown): value is Record<string, boolean> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function scoreEndpoint(ep: { contentType: string; responseAnalysis: AnalyzedEndpoint['responseAnalysis']; pattern: string; status: number | null; hasSearchParam: boolean; hasPaginationParam: boolean; hasLimitParam: boolean }): number {
   let s = 0;
   if (ep.contentType.includes('json')) s += 10;
   if (ep.responseAnalysis) { s += 5; s += Math.min(ep.responseAnalysis.itemCount, 10); s += Object.keys(ep.responseAnalysis.detectedFields).length * 2; }
@@ -321,7 +381,7 @@ function inferCapabilitiesFromEndpoints(
 /** Write explore artifacts (manifest, endpoints, capabilities, auth, stores) to disk. */
 async function writeExploreArtifacts(
   targetDir: string,
-  result: Record<string, any>,
+  result: Omit<ExploreResult, 'out_dir'>,
   analyzedEndpoints: AnalyzedEndpoint[],
   stores: DiscoveredStore[],
 ): Promise<void> {
@@ -354,12 +414,12 @@ async function writeExploreArtifacts(
 export async function exploreUrl(
   url: string,
   opts: {
-    BrowserFactory: new () => any;
+    BrowserFactory: new () => IBrowserFactory;
     site?: string; goal?: string; authenticated?: boolean;
     outDir?: string; waitSeconds?: number; query?: string;
     clickLabels?: string[]; auto?: boolean; workspace?: string;
   },
-): Promise<Record<string, any>> {
+): Promise<ExploreResult> {
   const waitSeconds = opts.waitSeconds ?? 3.0;
   const exploreTimeout = Math.max(DEFAULT_BROWSER_EXPLORE_TIMEOUT, 45.0 + waitSeconds * 8.0);
 
@@ -432,7 +492,10 @@ export async function exploreUrl(
 
       // Step 6: Detect framework
       let framework: Record<string, boolean> = {};
-      try { const fw = await page.evaluate(FRAMEWORK_DETECT_JS); if (fw && typeof fw === 'object') framework = fw; } catch {}
+      try {
+        const fw = await page.evaluate(FRAMEWORK_DETECT_JS);
+        if (isBooleanRecord(fw)) framework = fw;
+      } catch {}
 
       // Step 6.5: Discover stores (Pinia / Vuex)
       let stores: DiscoveredStore[] = [];
@@ -467,7 +530,7 @@ export async function exploreUrl(
   }, { workspace: opts.workspace });
 }
 
-export function renderExploreSummary(result: Record<string, any>): string {
+export function renderExploreSummary(result: ExploreResult): string {
   const lines = [
     'opencli probe: OK', `Site: ${result.site}`, `URL: ${result.target_url}`,
     `Title: ${result.title || '(none)'}`, `Strategy: ${result.top_strategy}`,
@@ -492,10 +555,15 @@ export function renderExploreSummary(result: Record<string, any>): string {
   return lines.join('\n');
 }
 
-async function readPageMetadata(page: any /* IPage */): Promise<{ url: string; title: string }> {
+async function readPageMetadata(page: IPage): Promise<{ url: string; title: string }> {
   try {
     const result = await page.evaluate(`() => ({ url: window.location.href, title: document.title || '' })`);
-    if (result && typeof result === 'object') return { url: String(result.url ?? ''), title: String(result.title ?? '') };
+    if (result && typeof result === 'object' && !Array.isArray(result)) {
+      return {
+        url: String((result as Record<string, unknown>).url ?? ''),
+        title: String((result as Record<string, unknown>).title ?? ''),
+      };
+    }
   } catch {}
   return { url: '', title: '' };
 }

package/src/generate.ts

@@ -9,10 +9,59 @@
  */
 
 import { exploreUrl } from './explore.js';
-import { synthesizeFromExplore } from './synthesize.js';
+import type { IBrowserFactory } from './runtime.js';
+import { synthesizeFromExplore, type SynthesizeCandidateSummary, type SynthesizeResult } from './synthesize.js';
 
 // TODO: implement real CLI registration (copy candidate YAML to user clis dir)
-function registerCandidates(_opts: any): any { return { ok: true, count: 0 }; }
+interface RegisterCandidatesOptions {
+  target: string;
+  builtinClis?: string;
+  userClis?: string;
+  name?: string;
+}
+
+interface RegisterCandidatesResult {
+  ok: boolean;
+  count: number;
+}
+
+export interface GenerateCliOptions {
+  url: string;
+  BrowserFactory: new () => IBrowserFactory;
+  builtinClis?: string;
+  userClis?: string;
+  goal?: string | null;
+  site?: string;
+  waitSeconds?: number;
+  top?: number;
+  register?: boolean;
+  workspace?: string;
+}
+
+export interface GenerateCliResult {
+  ok: boolean;
+  goal?: string | null;
+  normalized_goal?: string | null;
+  site: string;
+  selected_candidate: SynthesizeCandidateSummary | null;
+  selected_command: string;
+  explore: {
+    endpoint_count: number;
+    api_endpoint_count: number;
+    capability_count: number;
+    top_strategy: string;
+    framework: Record<string, boolean>;
+  };
+  synthesize: {
+    candidate_count: number;
+    candidates: Array<Pick<SynthesizeCandidateSummary, 'name' | 'strategy' | 'confidence'>>;
+  };
+  register: RegisterCandidatesResult | null;
+}
+
+function registerCandidates(_opts: RegisterCandidatesOptions): RegisterCandidatesResult {
+  return { ok: true, count: 0 };
+}
 
 const CAPABILITY_ALIASES: Record<string, string[]> = {
   search:    ['search', '搜索', '查找', 'query', 'keyword'],
@@ -41,7 +90,7 @@ function normalizeGoal(goal?: string | null): string | null {
 /**
  * Select the best candidate matching the user's goal.
  */
-function selectCandidate(candidates: any[], goal?: string | null): any {
+function selectCandidate(candidates: SynthesizeResult['candidates'], goal?: string | null): SynthesizeCandidateSummary | null {
   if (!candidates.length) return null;
   if (!goal) return candidates[0]; // highest confidence first
 
@@ -58,12 +107,12 @@ function selectCandidate(candidates: any[], goal?: string | null): any {
   return partial ?? candidates[0];
 }
 
-export async function generateCliFromUrl(opts: any): Promise<any> {
+export async function generateCliFromUrl(opts: GenerateCliOptions): Promise<GenerateCliResult> {
   // Step 1: Deep Explore
   const exploreResult = await exploreUrl(opts.url, {
     BrowserFactory: opts.BrowserFactory,
     site: opts.site,
-    goal: normalizeGoal(opts.goal) ?? opts.goal,
+    goal: normalizeGoal(opts.goal) ?? opts.goal ?? undefined,
     waitSeconds: opts.waitSeconds ?? 3,
     workspace: opts.workspace,
   });
@@ -75,10 +124,10 @@ export async function generateCliFromUrl(opts: any): Promise<any> {
 
   // Step 3: Select best candidate for goal
   const selected = selectCandidate(synthesizeResult.candidates ?? [], opts.goal);
-  const selectedSite = selected?.site ?? synthesizeResult.site ?? exploreResult.site;
+  const selectedSite = synthesizeResult.site ?? exploreResult.site;
 
   // Step 4: Register (if requested)
-  let registerResult: any = null;
+  let registerResult: RegisterCandidatesResult | null = null;
   if (opts.register !== false && synthesizeResult.candidate_count > 0) {
     try {
       registerResult = registerCandidates({
@@ -108,7 +157,7 @@ export async function generateCliFromUrl(opts: any): Promise<any> {
     },
     synthesize: {
       candidate_count: synthesizeResult.candidate_count,
-      candidates: (synthesizeResult.candidates ?? []).map((c: any) => ({
+      candidates: (synthesizeResult.candidates ?? []).map((c) => ({
         name: c.name,
         strategy: c.strategy,
         confidence: c.confidence,
@@ -118,7 +167,7 @@ export async function generateCliFromUrl(opts: any): Promise<any> {
   };
 }
 
-export function renderGenerateSummary(r: any): string {
+export function renderGenerateSummary(r: GenerateCliResult): string {
   const lines = [
     `opencli generate: ${r.ok ? 'OK' : 'FAIL'}`,
     `Site: ${r.site}`,

package/src/main.ts

@@ -6,7 +6,7 @@
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { discoverClis } from './discovery.js';
+import { discoverClis, discoverPlugins } from './discovery.js';
 import { getCompletions } from './completion.js';
 import { runCli } from './cli.js';
 
@@ -16,6 +16,7 @@ const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
 const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
 
 await discoverClis(BUILTIN_CLIS, USER_CLIS);
+await discoverPlugins();
 
 // ── Fast-path: handle --get-completions before commander parses ─────────
 // Usage: opencli --get-completions --cursor <N> [word1 word2 ...]

package/src/pipeline/executor.test.ts

@@ -4,6 +4,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { executePipeline } from './index.js';
+import { ConfigError } from '../errors.js';
 import type { IPage } from '../types.js';
 
 /** Create a minimal mock page for testing */
@@ -16,6 +17,7 @@ function createMockPage(overrides: Partial<IPage> = {}): IPage {
     click: vi.fn(),
     typeText: vi.fn(),
     pressKey: vi.fn(),
+    getFormState: vi.fn().mockResolvedValue({}),
     wait: vi.fn(),
     tabs: vi.fn().mockResolvedValue([]),
     closeTab: vi.fn(),
@@ -24,6 +26,7 @@ function createMockPage(overrides: Partial<IPage> = {}): IPage {
     networkRequests: vi.fn().mockResolvedValue([]),
     consoleMessages: vi.fn().mockResolvedValue(''),
     scroll: vi.fn(),
+    scrollTo: vi.fn(),
     autoScroll: vi.fn(),
     installInterceptor: vi.fn(),
     getInterceptedRequests: vi.fn().mockResolvedValue([]),
@@ -79,6 +82,32 @@ describe('executePipeline', () => {
     ]);
   });
 
+  it('runs inline select inside map step', async () => {
+    const page = createMockPage({
+      evaluate: vi.fn().mockResolvedValue({
+        posts: [
+          { title: 'First', rank: 1 },
+          { title: 'Second', rank: 2 },
+        ],
+      }),
+    });
+    const result = await executePipeline(page, [
+      { evaluate: 'test' },
+      {
+        map: {
+          select: 'posts',
+          title: '${{ item.title }}',
+          rank: '${{ item.rank }}',
+        },
+      },
+    ]);
+
+    expect(result).toEqual([
+      { title: 'First', rank: 1 },
+      { title: 'Second', rank: 2 },
+    ]);
+  });
+
   it('executes limit step', async () => {
     const page = createMockPage({
       evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
@@ -120,13 +149,13 @@ describe('executePipeline', () => {
     expect(page.wait).toHaveBeenCalledWith(2);
   });
 
-  it('handles unknown steps gracefully in debug mode', async () => {
-    const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-    await executePipeline(null, [
+  it('fails fast on unknown steps', async () => {
+    await expect(executePipeline(null, [
+      { unknownStep: 'test' },
+    ], { debug: true })).rejects.toBeInstanceOf(ConfigError);
+    await expect(executePipeline(null, [
       { unknownStep: 'test' },
-    ], { debug: true });
-    expect(stderr).toHaveBeenCalledWith(expect.stringContaining('Unknown step'));
-    stderr.mockRestore();
+    ], { debug: true })).rejects.toThrow('Unknown pipeline step "unknownStep"');
   });
 
   it('passes args through template rendering', async () => {

package/src/pipeline/executor.ts

@@ -2,46 +2,95 @@
  * Pipeline executor: runs YAML pipeline steps sequentially.
  */
 
-import chalk from 'chalk';
+
 import type { IPage } from '../types.js';
 import { getStep, type StepHandler } from './registry.js';
 import { log } from '../logger.js';
+import { ConfigError } from '../errors.js';
 
 export interface PipelineContext {
-  args?: Record<string, any>;
+  args?: Record<string, unknown>;
   debug?: boolean;
+  /** Max retry attempts per step (default: 2 for browser steps, 0 for others) */
+  stepRetries?: number;
 }
 
+/** Steps that interact with the browser and may fail transiently */
+const BROWSER_STEPS = new Set(['navigate', 'evaluate', 'click', 'type', 'press', 'wait', 'snapshot', 'scroll']);
+
 export async function executePipeline(
   page: IPage | null,
-  pipeline: any[],
+  pipeline: unknown[],
   ctx: PipelineContext = {},
-): Promise<any> {
+): Promise<unknown> {
   const args = ctx.args ?? {};
   const debug = ctx.debug ?? false;
-  let data: any = null;
+  let data: unknown = null;
   const total = pipeline.length;
 
-  for (let i = 0; i < pipeline.length; i++) {
-    const step = pipeline[i];
-    if (!step || typeof step !== 'object') continue;
-    for (const [op, params] of Object.entries(step)) {
-      if (debug) debugStepStart(i + 1, total, op, params);
+  try {
+    for (let i = 0; i < pipeline.length; i++) {
+      const step = pipeline[i];
+      if (!step || typeof step !== 'object') continue;
+      for (const [op, params] of Object.entries(step)) {
+        if (debug) debugStepStart(i + 1, total, op, params);
 
-      const handler = getStep(op);
-      if (handler) {
-        data = await handler(page, params, data, args);
-      } else {
-        if (debug) log.warn(`Unknown step: ${op}`);
-      }
+        const handler = getStep(op);
+        if (handler) {
+          data = await executeStepWithRetry(handler, page, params, data, args, op, ctx.stepRetries);
+        } else {
+          throw new ConfigError(
+            `Unknown pipeline step "${op}" at index ${i}.`,
+            'Check the YAML pipeline step name or register the custom step before execution.',
+          );
+        }
 
-      if (debug) debugStepResult(op, data);
+        if (debug) debugStepResult(op, data);
+      }
+    }
+  } 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 */ }
     }
+    throw err;
   }
   return data;
 }
 
-function debugStepStart(stepNum: number, total: number, op: string, params: any): void {
+async function executeStepWithRetry(
+  handler: StepHandler,
+  page: IPage | null,
+  params: unknown,
+  data: unknown,
+  args: Record<string, unknown>,
+  op: string,
+  configRetries?: number,
+): Promise<unknown> {
+  const maxRetries = configRetries ?? (BROWSER_STEPS.has(op) ? 2 : 0);
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await handler(page, params, data, args);
+    } catch (err) {
+      if (attempt >= maxRetries) throw err;
+      // Only retry on transient browser errors
+      const msg = err instanceof Error ? err.message : '';
+      const isTransient = msg.includes('Extension disconnected')
+        || msg.includes('attach failed')
+        || msg.includes('no longer exists')
+        || msg.includes('CDP connection')
+        || msg.includes('Daemon command failed');
+      if (!isTransient) throw err;
+      // Brief delay before retry
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+  // Unreachable
+  throw new Error(`Step "${op}" failed after ${maxRetries} retries`);
+}
+
+function debugStepStart(stepNum: number, total: number, op: string, params: unknown): void {
   let preview = '';
   if (typeof params === 'string') {
     preview = params.length <= 80 ? ` → ${params}` : ` → ${params.slice(0, 77)}...`;
@@ -51,7 +100,7 @@ function debugStepStart(stepNum: number, total: number, op: string, params: any)
   log.step(stepNum, total, op, preview);
 }
 
-function debugStepResult(op: string, data: any): void {
+function debugStepResult(op: string, data: unknown): void {
   if (data === null || data === undefined) {
     log.stepResult('(no data)');
   } else if (Array.isArray(data)) {

package/src/pipeline/registry.ts

@@ -18,11 +18,11 @@ import { stepDownload } from './steps/download.js';
  * TData is the type of the `data` state flowing into the step.
  * TResult is the expected return type.
  */
-export type StepHandler<TData = any, TResult = any> = (
+export type StepHandler<TData = unknown, TResult = unknown, TParams = unknown> = (
   page: IPage | null,
-  params: any,
+  params: TParams,
   data: TData,
-  args: Record<string, any>
+  args: Record<string, unknown>
 ) => Promise<TResult>;
 
 const _stepRegistry = new Map<string, StepHandler>();