@jackwener/opencli 1.1.1 → 1.2.0

package/src/pipeline/steps/fetch.ts

@@ -5,6 +5,10 @@
 import type { IPage } from '../../types.js';
 import { render } from '../template.js';
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 /** Simple async concurrency limiter */
 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);
@@ -25,9 +29,9 @@ async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, inde
 /** Single URL fetch helper */
 async function fetchSingle(
   page: IPage | null, url: string, method: string,
-  queryParams: Record<string, any>, headers: Record<string, any>,
-  args: Record<string, any>, data: any,
-): Promise<any> {
+  queryParams: Record<string, unknown>, headers: Record<string, unknown>,
+  args: Record<string, unknown>, data: unknown,
+): Promise<unknown> {
   const renderedParams: Record<string, string> = {};
   for (const [k, v] of Object.entries(queryParams)) renderedParams[k] = String(render(v, { args, data }));
   const renderedHeaders: Record<string, string> = {};
@@ -65,10 +69,10 @@ async function fetchSingle(
 async function fetchBatchInBrowser(
   page: IPage, urls: string[], method: string,
   headers: Record<string, string>, concurrency: number,
-): Promise<any[]> {
+): Promise<unknown[]> {
   const headersJs = JSON.stringify(headers);
   const urlsJs = JSON.stringify(urls);
-  return page.evaluate(`
+  return (await page.evaluate(`
     async () => {
       const urls = ${urlsJs};
       const method = "${method}";
@@ -94,19 +98,20 @@ async function fetchBatchInBrowser(
       await Promise.all(workers);
       return results;
     }
-  `);
+  `)) as unknown[];
 }
 
-export async function stepFetch(page: IPage | null, params: any, data: any, args: Record<string, any>): Promise<any> {
-  const urlOrObj = typeof params === 'string' ? params : (params?.url ?? '');
-  const method = params?.method ?? 'GET';
-  const queryParams: Record<string, any> = params?.params ?? {};
-  const headers: Record<string, any> = params?.headers ?? {};
+export async function stepFetch(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
+  const paramObject = isRecord(params) ? params : {};
+  const urlOrObj = typeof params === 'string' ? params : (paramObject.url ?? '');
+  const method = typeof paramObject.method === 'string' ? paramObject.method : 'GET';
+  const queryParams = isRecord(paramObject.params) ? paramObject.params : {};
+  const headers = isRecord(paramObject.headers) ? paramObject.headers : {};
   const urlTemplate = String(urlOrObj);
 
   // Per-item fetch when data is array and URL references item
   if (Array.isArray(data) && urlTemplate.includes('item')) {
-    const concurrency = typeof params?.concurrency === 'number' ? params.concurrency : 5;
+    const concurrency = typeof paramObject.concurrency === 'number' ? paramObject.concurrency : 5;
 
     // Render all URLs upfront
     const renderedHeaders: Record<string, string> = {};
@@ -114,7 +119,7 @@ export async function stepFetch(page: IPage | null, params: any, data: any, args
     const renderedParams: Record<string, string> = {};
     for (const [k, v] of Object.entries(queryParams)) renderedParams[k] = String(render(v, { args, data }));
 
-    const urls = data.map((item: any, index: number) => {
+    const urls = data.map((item, index) => {
       let url = String(render(urlTemplate, { args, data, item, index }));
       if (Object.keys(renderedParams).length > 0) {
         const qs = new URLSearchParams(renderedParams).toString();

package/src/pipeline/steps/transform.ts

@@ -2,14 +2,19 @@
  * Pipeline steps: data transforms — select, map, filter, sort, limit.
  */
 
+import type { IPage } from '../../types.js';
 import { render, evalExpr } from '../template.js';
 
-export async function stepSelect(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export async function stepSelect(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   const pathStr = String(render(params, { args, data }));
   if (data && typeof data === 'object') {
-    let current = data;
+    let current: unknown = data;
     for (const part of pathStr.split('.')) {
-      if (current && typeof current === 'object' && !Array.isArray(current)) current = (current as any)[part];
+      if (isRecord(current)) current = current[part];
       else if (Array.isArray(current) && /^\d+$/.test(part)) current = current[parseInt(part, 10)];
       else return null;
     }
@@ -18,33 +23,53 @@ export async function stepSelect(_page: any, params: any, data: any, args: Recor
   return data;
 }
 
-export async function stepMap(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepMap(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (!data || typeof data !== 'object') return data;
-  let items: any[] = Array.isArray(data) ? data : [data];
-  if (!Array.isArray(data) && typeof data === 'object' && 'data' in data) items = data.data;
-  const result: any[] = [];
+  let source: unknown = data;
+
+  // Support inline select: { map: { select: 'path', key: '${{ item.x }}' } }
+  if (isRecord(params) && 'select' in params) {
+    source = await stepSelect(null, params.select, data, args);
+  }
+
+  if (!source || typeof source !== 'object') return source;
+
+  let items: unknown[] = Array.isArray(source) ? source : [source];
+  if (isRecord(source) && Array.isArray(source.data)) items = source.data;
+  const result: Array<Record<string, unknown>> = [];
+  const templateParams = isRecord(params) ? params : {};
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
-    const row: Record<string, any> = {};
-    for (const [key, template] of Object.entries(params)) row[key] = render(template, { args, data, item, index: i });
+    const row: Record<string, unknown> = {};
+    for (const [key, template] of Object.entries(templateParams)) {
+      if (key === 'select') continue;
+      row[key] = render(template, { args, data: source, item, index: i });
+    }
     result.push(row);
   }
   return result;
 }
 
-export async function stepFilter(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepFilter(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (!Array.isArray(data)) return data;
   return data.filter((item, i) => evalExpr(String(params), { args, item, index: i }));
 }
 
-export async function stepSort(_page: any, params: any, data: any, _args: Record<string, any>): Promise<any> {
+export async function stepSort(_page: IPage | null, params: unknown, data: unknown, _args: Record<string, unknown>): Promise<unknown> {
   if (!Array.isArray(data)) return data;
-  const key = typeof params === 'object' ? (params.by ?? '') : String(params);
-  const reverse = typeof params === 'object' ? params.order === 'desc' : false;
-  return [...data].sort((a, b) => { const va = a[key] ?? ''; const vb = b[key] ?? ''; const cmp = va < vb ? -1 : va > vb ? 1 : 0; return reverse ? -cmp : cmp; });
+  const key = isRecord(params) ? String(params.by ?? '') : String(params);
+  const reverse = isRecord(params) ? params.order === 'desc' : false;
+  return [...data].sort((a, b) => {
+    const left = isRecord(a) ? a[key] : undefined;
+    const right = isRecord(b) ? b[key] : undefined;
+    const va = left ?? '';
+    const vb = right ?? '';
+    const cmp = va < vb ? -1 : va > vb ? 1 : 0;
+    return reverse ? -cmp : cmp;
+  });
 }
 
-export async function stepLimit(_page: any, params: any, data: any, args: Record<string, any>): Promise<any> {
+export async function stepLimit(_page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   if (!Array.isArray(data)) return data;
   return data.slice(0, Number(render(params, { args, data })));
 }

package/src/pipeline/template.test.ts

@@ -57,6 +57,15 @@ describe('evalExpr', () => {
   it('resolves simple path', () => {
     expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
   });
+  it('evaluates JS helper expressions', () => {
+    expect(evalExpr('encodeURIComponent(args.keyword)', { args: { keyword: 'hello world' } })).toBe('hello%20world');
+  });
+  it('evaluates ternary expressions', () => {
+    expect(evalExpr("args.kind === 'tech' ? 'technology' : args.kind", { args: { kind: 'tech' } })).toBe('technology');
+  });
+  it('evaluates method calls on values', () => {
+    expect(evalExpr("args.username.startsWith('@') ? args.username : '@' + args.username", { args: { username: 'alice' } })).toBe('@alice');
+  });
   it('applies join filter', () => {
     expect(evalExpr('item.tags | join(,)', { item: { tags: ['a', 'b', 'c'] } })).toBe('a,b,c');
   });
@@ -104,6 +113,15 @@ describe('render', () => {
   it('renders URL template', () => {
     expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
   });
+  it('renders inline helper expressions', () => {
+    expect(render('https://example.com/search?q=${{ encodeURIComponent(args.keyword) }}', { args: { keyword: 'hello world' } })).toBe('https://example.com/search?q=hello%20world');
+  });
+  it('renders full multiline expressions', () => {
+    expect(render("${{\n  args.topic ? `https://medium.com/tag/${args.topic}` : 'https://medium.com/tag/technology'\n}}", { args: { topic: 'ai' } })).toBe('https://medium.com/tag/ai');
+  });
+  it('renders block expressions with surrounding whitespace', () => {
+    expect(render("\n  ${{ args.kind === 'tech' ? 'technology' : args.kind }}\n", { args: { kind: 'tech' } })).toBe('technology');
+  });
 });
 
 describe('normalizeEvaluateSource', () => {

package/src/pipeline/template.ts

@@ -3,20 +3,25 @@
  */
 
 export interface RenderContext {
-  args?: Record<string, any>;
-  data?: any;
-  item?: any;
+  args?: Record<string, unknown>;
+  data?: unknown;
+  item?: unknown;
   index?: number;
 }
 
-export function render(template: any, ctx: RenderContext): any {
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function render(template: unknown, ctx: RenderContext): unknown {
   if (typeof template !== 'string') return template;
+  const trimmed = template.trim();
   // Full expression: entire string is a single ${{ ... }}
   // Use [^}] to prevent matching across }} boundaries (e.g. "${{ a }}-${{ b }}")
-  const fullMatch = template.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
-  if (fullMatch && !template.includes('}}-') && !template.includes('}}${{')) return evalExpr(fullMatch[1].trim(), ctx);
+  const fullMatch = trimmed.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
+  if (fullMatch && !trimmed.includes('}}-') && !trimmed.includes('}}${{')) return evalExpr(fullMatch[1].trim(), ctx);
   // Check if the entire string is a single expression (no other text around it)
-  const singleExpr = template.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
+  const singleExpr = trimmed.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
   if (singleExpr) {
     // Verify it's truly a single expression (no other ${{ inside)
     const inner = singleExpr[1];
@@ -25,7 +30,7 @@ export function render(template: any, ctx: RenderContext): any {
   return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
 }
 
-export function evalExpr(expr: string, ctx: RenderContext): any {
+export function evalExpr(expr: string, ctx: RenderContext): unknown {
   const args = ctx.args ?? {};
   const item = ctx.item ?? {};
   const data = ctx.data;
@@ -68,7 +73,10 @@ export function evalExpr(expr: string, ctx: RenderContext): any {
     return right.replace(/^['"]|['"]$/g, '');
   }
 
-  return resolvePath(expr, { args, item, data, index });
+  const resolved = resolvePath(expr, { args, item, data, index });
+  if (resolved !== null && resolved !== undefined) return resolved;
+
+  return evalJsExpr(expr, { args, item, data, index });
 }
 
 /**
@@ -77,7 +85,7 @@ export function evalExpr(expr: string, ctx: RenderContext): any {
  *   default(val), join(sep), upper, lower, truncate(n), trim,
  *   replace(old,new), keys, length, first, last, json
  */
-function applyFilter(filterExpr: string, value: any): any {
+function applyFilter(filterExpr: string, value: unknown): unknown {
   const match = filterExpr.match(/^(\w+)(?:\((.+)\))?$/);
   if (!match) return value;
   const [, name, rawArgs] = match;
@@ -145,32 +153,97 @@ function applyFilter(filterExpr: string, value: any): any {
       const parts = value.split(/[/\\]/);
       return parts[parts.length - 1] || value;
     }
+    case 'urlencode':
+      return typeof value === 'string' ? encodeURIComponent(value) : value;
+    case 'urldecode':
+      return typeof value === 'string' ? decodeURIComponent(value) : value;
     default:
       return value;
   }
 }
 
-export function resolvePath(pathStr: string, ctx: RenderContext): any {
+export function resolvePath(pathStr: string, ctx: RenderContext): unknown {
   const args = ctx.args ?? {};
   const item = ctx.item ?? {};
   const data = ctx.data;
   const index = ctx.index ?? 0;
   const parts = pathStr.split('.');
   const rootName = parts[0];
-  let obj: any; let rest: string[];
+  let obj: unknown;
+  let rest: string[];
   if (rootName === 'args') { obj = args; rest = parts.slice(1); }
   else if (rootName === 'item') { obj = item; rest = parts.slice(1); }
   else if (rootName === 'data') { obj = data; rest = parts.slice(1); }
   else if (rootName === 'index') return index;
   else { obj = item; rest = parts; }
   for (const part of rest) {
-    if (obj && typeof obj === 'object' && !Array.isArray(obj)) obj = obj[part];
+    if (isRecord(obj)) obj = obj[part];
     else if (Array.isArray(obj) && /^\d+$/.test(part)) obj = obj[parseInt(part, 10)];
     else return null;
   }
   return obj;
 }
 
+/**
+ * Evaluate arbitrary JS expressions as a last-resort fallback.
+ *
+ * ⚠️  SECURITY NOTE: Uses `new Function()` to execute the expression.
+ * This is acceptable here because:
+ *   1. YAML adapters are authored by trusted repo contributors only.
+ *   2. The expression runs in the same Node.js process (no sandbox).
+ *   3. Only a curated set of globals is exposed (no require/import/process/fs).
+ * If opencli ever loads untrusted third-party adapters, this MUST be replaced
+ * with a proper sandboxed evaluator.
+ */
+function evalJsExpr(expr: string, ctx: RenderContext): unknown {
+  // Guard against absurdly long expressions that could indicate injection.
+  if (expr.length > 2000) return undefined;
+
+  const args = ctx.args ?? {};
+  const item = ctx.item ?? {};
+  const data = ctx.data;
+  const index = ctx.index ?? 0;
+
+  try {
+    const fn = new Function(
+      'args',
+      'item',
+      'data',
+      'index',
+      'encodeURIComponent',
+      'decodeURIComponent',
+      'JSON',
+      'Math',
+      'Number',
+      'String',
+      'Boolean',
+      'Array',
+      'Object',
+      'Date',
+      `"use strict"; return (${expr});`,
+    );
+
+    return fn(
+      args,
+      item,
+      data,
+      index,
+      encodeURIComponent,
+      decodeURIComponent,
+      JSON,
+      Math,
+      Number,
+      String,
+      Boolean,
+      Array,
+      Object,
+      Date,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Normalize JavaScript source for browser evaluate() calls.
  */

package/src/pipeline/transform.test.ts

@@ -58,6 +58,19 @@ describe('stepMap', () => {
   it('returns null/undefined as-is', async () => {
     expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
   });
+
+  it('supports inline select before mapping', async () => {
+    const result = await stepMap(null, {
+      select: 'posts',
+      title: '${{ item.title }}',
+      rank: '${{ index + 1 }}',
+    }, { posts: [{ title: 'One' }, { title: 'Two' }] }, {});
+
+    expect(result).toEqual([
+      { title: 'One', rank: 1 },
+      { title: 'Two', rank: 2 },
+    ]);
+  });
 });
 
 describe('stepFilter', () => {
@@ -75,12 +88,12 @@ describe('stepFilter', () => {
 describe('stepSort', () => {
   it('sorts ascending by key', async () => {
     const result = await stepSort(null, 'score', SAMPLE_DATA, {});
-    expect(result.map((r: any) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+    expect((result as typeof SAMPLE_DATA).map((r) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
   });
 
   it('sorts descending', async () => {
     const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
-    expect(result.map((r: any) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+    expect((result as typeof SAMPLE_DATA).map((r) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
   });
 
   it('does not mutate original', async () => {

package/src/plugin.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for plugin management: install, uninstall, list.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PLUGINS_DIR } from './discovery.js';
+import { listPlugins, uninstallPlugin, _parseSource } from './plugin.js';
+
+describe('parseSource', () => {
+  it('parses github:user/repo format', () => {
+    const result = _parseSource('github:ByteYue/opencli-plugin-github-trending');
+    expect(result).toEqual({
+      cloneUrl: 'https://github.com/ByteYue/opencli-plugin-github-trending.git',
+      name: 'github-trending',
+    });
+  });
+
+  it('parses https URL format', () => {
+    const result = _parseSource('https://github.com/ByteYue/opencli-plugin-hot-digest');
+    expect(result).toEqual({
+      cloneUrl: 'https://github.com/ByteYue/opencli-plugin-hot-digest.git',
+      name: 'hot-digest',
+    });
+  });
+
+  it('strips opencli-plugin- prefix from name', () => {
+    const result = _parseSource('github:user/opencli-plugin-my-tool');
+    expect(result!.name).toBe('my-tool');
+  });
+
+  it('keeps name without prefix', () => {
+    const result = _parseSource('github:user/awesome-cli');
+    expect(result!.name).toBe('awesome-cli');
+  });
+
+  it('returns null for invalid source', () => {
+    expect(_parseSource('invalid')).toBeNull();
+    expect(_parseSource('npm:some-package')).toBeNull();
+  });
+});
+
+describe('listPlugins', () => {
+  const testDir = path.join(PLUGINS_DIR, '__test-list-plugin__');
+
+  afterEach(() => {
+    try { fs.rmSync(testDir, { recursive: true }); } catch {}
+  });
+
+  it('lists installed plugins', () => {
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'hello.yaml'), 'site: test\nname: hello\n');
+
+    const plugins = listPlugins();
+    const found = plugins.find(p => p.name === '__test-list-plugin__');
+    expect(found).toBeDefined();
+    expect(found!.commands).toContain('hello');
+  });
+
+  it('returns empty array when no plugins dir', () => {
+    // listPlugins should handle missing dir gracefully
+    const plugins = listPlugins();
+    expect(Array.isArray(plugins)).toBe(true);
+  });
+});
+
+describe('uninstallPlugin', () => {
+  const testDir = path.join(PLUGINS_DIR, '__test-uninstall__');
+
+  afterEach(() => {
+    try { fs.rmSync(testDir, { recursive: true }); } catch {}
+  });
+
+  it('removes plugin directory', () => {
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'test.yaml'), 'site: test');
+
+    uninstallPlugin('__test-uninstall__');
+    expect(fs.existsSync(testDir)).toBe(false);
+  });
+
+  it('throws for non-existent plugin', () => {
+    expect(() => uninstallPlugin('__nonexistent__')).toThrow('not installed');
+  });
+});