@jackwener/opencli 1.7.3 → 1.7.4

package/dist/src/output.test.js

@@ -2,17 +2,12 @@ import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
 import { render } from './output.js';
 describe('output TTY detection', () => {
     const originalIsTTY = process.stdout.isTTY;
-    const originalEnv = process.env.OUTPUT;
     let logSpy;
     beforeEach(() => {
         logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
     });
     afterEach(() => {
         Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, writable: true });
-        if (originalEnv === undefined)
-            delete process.env.OUTPUT;
-        else
-            process.env.OUTPUT = originalEnv;
         logSpy.mockRestore();
     });
     it('outputs YAML in non-TTY when format is default table', () => {
@@ -35,22 +30,6 @@ describe('output TTY detection', () => {
         const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
         expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
     });
-    it('OUTPUT env var overrides default table in non-TTY', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        process.env.OUTPUT = 'json';
-        render([{ name: 'alice' }], { fmt: 'table' });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
-    });
-    it('explicit -f flag takes precedence over OUTPUT env var', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        process.env.OUTPUT = 'json';
-        render([{ name: 'alice' }], { fmt: 'csv', fmtExplicit: true });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(out).toContain('name');
-        expect(out).toContain('alice');
-        expect(out).not.toContain('"name"'); // not JSON
-    });
     it('explicit -f table overrides non-TTY auto-downgrade', () => {
         Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
         render([{ name: 'alice' }], { fmt: 'table', fmtExplicit: true, columns: ['name'] });

package/dist/src/pipeline/steps/transform.js

@@ -40,7 +40,7 @@ export async function stepMap(_page, params, data, args) {
         for (const [key, template] of Object.entries(templateParams)) {
             if (key === 'select')
                 continue;
-            row[key] = render(template, { args, data: source, item, index: i });
+            row[key] = render(template, { args, data: source, root: data, item, index: i });
         }
         result.push(row);
     }

package/dist/src/pipeline/template.d.ts

@@ -4,6 +4,7 @@
 export interface RenderContext {
     args?: Record<string, unknown>;
     data?: unknown;
+    root?: unknown;
     item?: unknown;
     index?: number;
 }

package/dist/src/pipeline/template.js

@@ -26,6 +26,7 @@ export function evalExpr(expr, ctx) {
     const args = ctx.args ?? {};
     const item = ctx.item ?? {};
     const data = ctx.data;
+    const root = ctx.root;
     const index = ctx.index ?? 0;
     // ── Pipe filters: expr | filter1(arg) | filter2 ──
     // Split on single | (not ||) so "item.a || item.b | upper" works correctly.
@@ -45,12 +46,12 @@ export function evalExpr(expr, ctx) {
     if (/^\d+(\.\d+)?$/.test(expr))
         return Number(expr);
     // Try resolving as a simple dotted path (item.foo.bar, args.limit, index)
-    const resolved = resolvePath(expr, { args, item, data, index });
+    const resolved = resolvePath(expr, { args, item, data, root, index });
     if (resolved !== null && resolved !== undefined)
         return resolved;
     // Fallback: evaluate as JS in a sandboxed VM.
     // Handles ||, ??, arithmetic, ternary, method calls, etc. natively.
-    return evalJsExpr(expr, { args, item, data, index });
+    return evalJsExpr(expr, { args, item, data, root, index });
 }
 /**
  * Apply a named filter to a value.
@@ -143,6 +144,7 @@ export function resolvePath(pathStr, ctx) {
     const args = ctx.args ?? {};
     const item = ctx.item ?? {};
     const data = ctx.data;
+    const root = ctx.root;
     const index = ctx.index ?? 0;
     const parts = pathStr.split('.');
     const rootName = parts[0];
@@ -160,6 +162,10 @@ export function resolvePath(pathStr, ctx) {
         obj = data;
         rest = parts.slice(1);
     }
+    else if (rootName === 'root') {
+        obj = root;
+        rest = parts.slice(1);
+    }
     else if (rootName === 'index')
         return index;
     else {
@@ -261,6 +267,7 @@ function getReusableContext() {
         args: {},
         item: {},
         data: null,
+        root: null,
         index: 0,
         encodeURIComponent,
         decodeURIComponent,
@@ -279,7 +286,7 @@ function getReusableContext() {
 }
 /** Properties that are part of the sandbox's initial shape and safe to keep. */
 const SANDBOX_WHITELIST = new Set([
-    'args', 'item', 'data', 'index',
+    'args', 'item', 'data', 'root', 'index',
     'encodeURIComponent', 'decodeURIComponent',
     'JSON', 'Math', 'Number', 'String', 'Boolean', 'Array', 'Date',
 ]);
@@ -304,6 +311,7 @@ function evalJsExpr(expr, ctx) {
         sandbox.args = sanitizeContext(ctx.args ?? {});
         sandbox.item = sanitizeContext(ctx.item ?? {});
         sandbox.data = sanitizeContext(ctx.data);
+        sandbox.root = sanitizeContext(ctx.root);
         sandbox.index = ctx.index ?? 0;
         return script.runInContext(context, { timeout: 50 });
     }

package/dist/src/pipeline/template.test.js

@@ -22,6 +22,9 @@ describe('resolvePath', () => {
     it('resolves data path', () => {
         expect(resolvePath('data.items', { data: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
     });
+    it('resolves root path', () => {
+        expect(resolvePath('root.items', { root: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
     it('returns null for missing path', () => {
         expect(resolvePath('args.missing', { args: {} })).toBeUndefined();
     });

package/dist/src/pipeline/transform.test.js

@@ -60,6 +60,20 @@ describe('stepMap', () => {
             { title: 'Two', rank: 2 },
         ]);
     });
+    it('keeps data bound to the selected source and exposes root separately', async () => {
+        const result = await stepMap(null, {
+            select: 'bids',
+            bid_price: '${{ data[index][0] }}',
+            ask_price: '${{ root.asks[index][0] }}',
+        }, {
+            bids: [['100', '2'], ['99', '3']],
+            asks: [['101', '1'], ['102', '4']],
+        }, {});
+        expect(result).toEqual([
+            { bid_price: '100', ask_price: '101' },
+            { bid_price: '99', ask_price: '102' },
+        ]);
+    });
 });
 describe('stepFilter', () => {
     it('filters by expression', async () => {

package/dist/src/plugin.d.ts

@@ -86,7 +86,13 @@ export declare function getCommitHash(dir: string): string | undefined;
 export declare function validatePluginStructure(pluginDir: string): ValidationResult;
 declare function installDependencies(dir: string): void;
 /**
- * Monorepo lifecycle: install shared deps once at repo root, then finalize each sub-plugin.
+ * Monorepo lifecycle: install shared deps at repo root, then install and finalize each sub-plugin.
+ *
+ * The root install covers monorepos that use npm workspaces to hoist dependencies.
+ * For monorepos that do NOT use workspaces, sub-plugins may declare their own
+ * production dependencies in their package.json.  We install those per sub-plugin
+ * so that runtime imports (e.g. `undici`) can be resolved from the sub-plugin
+ * directory.  When the root already satisfies all deps this is a fast no-op.
  */
 declare function postInstallMonorepoLifecycle(repoDir: string, pluginDirs: string[]): void;
 /**

package/dist/src/plugin.js

@@ -492,6 +492,19 @@ export function validatePluginStructure(pluginDir) {
     }
     return { valid: errors.length === 0, errors };
 }
+/** Check whether a directory has its own production dependencies in package.json. */
+function hasOwnDependencies(dir) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.dependencies != null && Object.keys(pkg.dependencies).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 function installDependencies(dir) {
     const pkgJsonPath = path.join(dir, 'package.json');
     if (!fs.existsSync(pkgJsonPath))
@@ -523,11 +536,20 @@ function postInstallLifecycle(pluginDir) {
     finalizePluginRuntime(pluginDir);
 }
 /**
- * Monorepo lifecycle: install shared deps once at repo root, then finalize each sub-plugin.
+ * Monorepo lifecycle: install shared deps at repo root, then install and finalize each sub-plugin.
+ *
+ * The root install covers monorepos that use npm workspaces to hoist dependencies.
+ * For monorepos that do NOT use workspaces, sub-plugins may declare their own
+ * production dependencies in their package.json.  We install those per sub-plugin
+ * so that runtime imports (e.g. `undici`) can be resolved from the sub-plugin
+ * directory.  When the root already satisfies all deps this is a fast no-op.
  */
 function postInstallMonorepoLifecycle(repoDir, pluginDirs) {
     installDependencies(repoDir);
     for (const pluginDir of pluginDirs) {
+        if (pluginDir !== repoDir && hasOwnDependencies(pluginDir)) {
+            installDependencies(pluginDir);
+        }
         finalizePluginRuntime(pluginDir);
     }
 }

package/dist/src/plugin.test.js

@@ -545,13 +545,27 @@ describe('postInstallMonorepoLifecycle', () => {
     afterEach(() => {
         fs.rmSync(repoDir, { recursive: true, force: true });
     });
-    it('installs dependencies once at the monorepo root, not in each sub-plugin', () => {
+    it('installs dependencies at the monorepo root and skips sub-plugins without own dependencies', () => {
         _postInstallMonorepoLifecycle(repoDir, [subDir]);
         const npmCalls = mockExecFileSync.mock.calls.filter(([cmd, args]) => cmd === 'npm' && Array.isArray(args) && args[0] === 'install');
         expect(npmCalls).toHaveLength(1);
         expect(npmCalls[0][2]).toMatchObject({ cwd: repoDir });
         expect(npmCalls.some(([, , opts]) => opts?.cwd === subDir)).toBe(false);
     });
+    it('also installs dependencies in sub-plugins that declare their own production dependencies', () => {
+        // Give the sub-plugin its own production dependencies
+        fs.writeFileSync(path.join(subDir, 'package.json'), JSON.stringify({
+            name: 'opencli-plugin-alpha',
+            version: '1.0.0',
+            type: 'module',
+            dependencies: { undici: '^8.0.0' },
+        }));
+        _postInstallMonorepoLifecycle(repoDir, [subDir]);
+        const npmCalls = mockExecFileSync.mock.calls.filter(([cmd, args]) => cmd === 'npm' && Array.isArray(args) && args[0] === 'install');
+        expect(npmCalls).toHaveLength(2);
+        expect(npmCalls[0][2]).toMatchObject({ cwd: repoDir });
+        expect(npmCalls[1][2]).toMatchObject({ cwd: subDir });
+    });
 });
 describe('updateAllPlugins', () => {
     const testDirA = path.join(PLUGINS_DIR, 'plugin-a');

package/dist/src/types.d.ts

@@ -72,7 +72,7 @@ export interface IPage {
     getInterceptedRequests(): Promise<any[]>;
     waitForCapture(timeout?: number): Promise<void>;
     screenshot(options?: ScreenshotOptions): Promise<string>;
-    startNetworkCapture?(pattern?: string): Promise<void>;
+    startNetworkCapture?(pattern?: string): Promise<boolean>;
     readNetworkCapture?(): Promise<unknown[]>;
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "publishConfig": {
     "access": "public"
   },