@jackwener/opencli 1.7.2 → 1.7.4

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/registry.js

@@ -77,10 +77,9 @@ export function registerCommand(cmd) {
     const normalized = normalizeCommand(cmd);
     const canonicalKey = fullName(normalized);
     const existing = _registry.get(canonicalKey);
-    if (existing) {
-        for (const [key, value] of _registry.entries()) {
-            if (value === existing && key !== canonicalKey)
-                _registry.delete(key);
+    if (existing?.aliases) {
+        for (const alias of existing.aliases) {
+            _registry.delete(`${existing.site}/${alias}`);
         }
     }
     const aliases = normalizeAliases(normalized.aliases, normalized.name);

package/dist/src/types.d.ts

@@ -44,6 +44,8 @@ export interface IPage {
         settleMs?: number;
     }): Promise<void>;
     evaluate(js: string): Promise<any>;
+    /** Safely evaluate JS with pre-serialized arguments — prevents injection. */
+    evaluateWithArgs?(js: string, args: Record<string, unknown>): Promise<any>;
     getCookies(opts?: {
         domain?: string;
         url?: string;
@@ -70,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/dist/src/update-check.d.ts

@@ -8,6 +8,13 @@
  * - Notice appears AFTER command output, not before (same as npm/gh/yarn)
  * - Never delays or blocks the CLI command
  */
+interface GitHubReleaseAsset {
+    name: string;
+}
+interface GitHubRelease {
+    tag_name: string;
+    assets?: GitHubReleaseAsset[];
+}
 /**
  * Register a process exit hook that prints an update notice if a newer
  * version was found on the last background check.
@@ -15,8 +22,15 @@
  * Skipped during --get-completions to avoid polluting shell completion output.
  */
 export declare function registerUpdateNoticeOnExit(): void;
+declare function extractLatestExtensionVersionFromReleases(releases: GitHubRelease[]): string | undefined;
 /**
  * Kick off a background fetch to npm registry. Writes to cache for next run.
  * Fully non-blocking — never awaited.
  */
 export declare function checkForUpdateBackground(): void;
+/**
+ * Get the cached latest extension version (if available).
+ * Used by `opencli doctor` to report extension updates.
+ */
+export declare function getCachedLatestExtensionVersion(): string | undefined;
+export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, };

package/dist/src/update-check.js

@@ -17,6 +17,7 @@ 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';
+const GITHUB_RELEASES_URL = 'https://api.github.com/repos/jackwener/OpenCLI/releases?per_page=20';
 // Read cache once at module load — shared by both exported functions
 const _cache = (() => {
     try {
@@ -26,10 +27,13 @@ const _cache = (() => {
         return null;
     }
 })();
-function writeCache(latestVersion) {
+function writeCache(latestVersion, latestExtensionVersion) {
     try {
         fs.mkdirSync(CACHE_DIR, { recursive: true });
-        fs.writeFileSync(CACHE_FILE, JSON.stringify({ lastCheck: Date.now(), latestVersion }), 'utf-8');
+        const data = { lastCheck: Date.now(), latestVersion };
+        if (latestExtensionVersion)
+            data.latestExtensionVersion = latestExtensionVersion;
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(data), 'utf-8');
     }
     catch {
         // Best-effort; never fail
@@ -80,6 +84,38 @@ export function registerUpdateNoticeOnExit() {
         }
     });
 }
+function extractLatestExtensionVersionFromReleases(releases) {
+    for (const release of releases) {
+        for (const asset of release.assets ?? []) {
+            const assetMatch = asset.name.match(/^opencli-extension-v(.+)\.zip$/);
+            if (assetMatch)
+                return assetMatch[1];
+        }
+        const tagMatch = release.tag_name.match(/^ext-v(.+)$/);
+        if (tagMatch)
+            return tagMatch[1];
+    }
+    return undefined;
+}
+/** Fetch the latest extension version from GitHub Releases. */
+async function fetchLatestExtensionVersion() {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch(GITHUB_RELEASES_URL, {
+            signal: controller.signal,
+            headers: { 'User-Agent': `opencli/${PKG_VERSION}`, Accept: 'application/vnd.github+json' },
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return undefined;
+        const releases = await res.json();
+        return extractLatestExtensionVersionFromReleases(releases);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Kick off a background fetch to npm registry. Writes to cache for next run.
  * Fully non-blocking — never awaited.
@@ -102,7 +138,8 @@ export function checkForUpdateBackground() {
                 return;
             const data = await res.json();
             if (typeof data.version === 'string') {
-                writeCache(data.version);
+                const extVersion = await fetchLatestExtensionVersion();
+                writeCache(data.version, extVersion);
             }
         }
         catch {
@@ -110,3 +147,11 @@ export function checkForUpdateBackground() {
         }
     })();
 }
+/**
+ * Get the cached latest extension version (if available).
+ * Used by `opencli doctor` to report extension updates.
+ */
+export function getCachedLatestExtensionVersion() {
+    return _cache?.latestExtensionVersion;
+}
+export { extractLatestExtensionVersionFromReleases as _extractLatestExtensionVersionFromReleases, };

package/dist/src/update-check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/update-check.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { _extractLatestExtensionVersionFromReleases as extractLatestExtensionVersionFromReleases } from './update-check.js';
+describe('extractLatestExtensionVersionFromReleases', () => {
+    it('reads the extension version from a versioned asset on a normal CLI release', () => {
+        expect(extractLatestExtensionVersionFromReleases([
+            {
+                tag_name: 'v1.7.3',
+                assets: [
+                    { name: 'opencli-extension.zip' },
+                    { name: 'opencli-extension-v1.0.2.zip' },
+                ],
+            },
+        ])).toBe('1.0.2');
+    });
+    it('falls back to ext-v tags for extension-only releases', () => {
+        expect(extractLatestExtensionVersionFromReleases([
+            {
+                tag_name: 'ext-v1.1.0',
+                assets: [{ name: 'opencli-extension.zip' }],
+            },
+        ])).toBe('1.1.0');
+    });
+    it('returns undefined when no extension version source exists', () => {
+        expect(extractLatestExtensionVersionFromReleases([
+            {
+                tag_name: 'v1.7.3',
+                assets: [{ name: 'opencli-extension.zip' }],
+            },
+        ])).toBeUndefined();
+    });
+});

package/package.json

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

package/scripts/fetch-adapters.js

@@ -21,7 +21,7 @@
 
 import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { join, resolve, dirname } from 'node:path';
+import { join, resolve, dirname, relative } from 'node:path';
 import { homedir } from 'node:os';
 
 const OPENCLI_DIR = join(homedir(), '.opencli');
@@ -82,8 +82,11 @@ function walkFiles(dir, prefix = '') {
  * Remove empty parent directories up to (but not including) stopAt.
  */
 function pruneEmptyDirs(filePath, stopAt) {
-  let dir = dirname(filePath);
-  while (dir !== stopAt && dir.startsWith(stopAt)) {
+  const boundary = resolve(stopAt);
+  let dir = resolve(dirname(filePath));
+  while (dir !== boundary) {
+    const rel = relative(boundary, dir);
+    if (!rel || rel.startsWith('..')) break;
     try {
       const entries = readdirSync(dir);
       if (entries.length > 0) break;
@@ -113,7 +116,15 @@ export function fetchAdapters() {
 
   const newOfficialFiles = new Set(walkFiles(BUILTIN_CLIS));
   const oldOfficialFiles = new Set(oldManifest?.files ?? []);
-  const oldHashes = oldManifest?.hashes ?? {};
+  const rawHashes = oldManifest?.hashes;
+  // Guard against corrupted manifest: if hashes is a non-object type (string, number,
+  // array), skip sync to avoid false-positive "changed" detection that deletes overrides.
+  // null/undefined are treated as empty (old manifests may lack the field).
+  if (rawHashes != null && (typeof rawHashes !== 'object' || Array.isArray(rawHashes))) {
+    log('Warning: adapter-manifest.json has corrupted hashes — skipping sync. Will fix on next run.');
+    return;
+  }
+  const oldHashes = rawHashes ?? {};
   mkdirSync(USER_CLIS_DIR, { recursive: true });
 
   // 1. Compute new hashes and detect which sites have changes
@@ -175,6 +186,24 @@ export function fetchAdapters() {
   }
   if (tsCleaned > 0) log(`Cleaned up ${tsCleaned} stale .ts adapter files`);
 
+  // 3b. Clean up stale .yaml/.yml adapter files left by older versions (pre-1.7.0)
+  // Older versions shipped adapters as YAML; current versions use .js only.
+  // These cause "Ignoring YAML adapter" warnings on every run (issue #953).
+  let yamlCleaned = 0;
+  for (const relPath of walkFiles(USER_CLIS_DIR)) {
+    if (relPath.endsWith('.yaml') || relPath.endsWith('.yml')) {
+      const jsCounterpart = relPath.replace(/\.ya?ml$/, '.js');
+      if (newOfficialFiles.has(jsCounterpart)) {
+        try {
+          unlinkSync(join(USER_CLIS_DIR, relPath));
+          pruneEmptyDirs(join(USER_CLIS_DIR, relPath), USER_CLIS_DIR);
+          yamlCleaned++;
+        } catch { /* ignore */ }
+      }
+    }
+  }
+  if (yamlCleaned > 0) log(`Cleaned up ${yamlCleaned} stale .yaml adapter files`);
+
   // 4. Clean up legacy compat shim files from ~/.opencli/
   // These were created by an older approach that placed re-export shims directly
   // in ~/.opencli/ (e.g., registry.js, errors.js, browser/). The current approach
@@ -245,15 +274,13 @@ export function fetchAdapters() {
   }, null, 2));
 
   log(`Synced adapters: ${cleared} local override(s) cleared` +
-    (tsCleaned > 0 ? `, ${tsCleaned} stale .ts files removed` : ''));
+    (tsCleaned > 0 ? `, ${tsCleaned} stale .ts files removed` : '') +
+    (yamlCleaned > 0 ? `, ${yamlCleaned} stale .yaml files removed` : ''));
 }
 
 function main() {
   // Skip in CI
   if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) return;
-  // Allow opt-out
-  if (process.env.OPENCLI_SKIP_FETCH === '1') return;
-
   // Only run on global install, explicit trigger, or first-run fallback
   const isGlobal = process.env.npm_config_global === 'true';
   const isExplicit = process.env.OPENCLI_FETCH === '1';