@jackwener/opencli 1.0.1 → 1.0.3

package/dist/clis/chatgpt/ask.js

@@ -1,5 +1,6 @@
 import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
+import { getVisibleChatMessages } from './ax.js';
 export const askCommand = cli({
     site: 'chatgpt',
     name: 'ask',
@@ -21,6 +22,7 @@ export const askCommand = cli({
             clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
         }
         catch { }
+        const messagesBefore = getVisibleChatMessages();
         // Send the message
         spawnSync('pbcopy', { input: text });
         execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
@@ -32,28 +34,27 @@ export const askCommand = cli({
             "-e 'keystroke return' " +
             "-e 'end tell'";
         execSync(cmd);
-        // Clear clipboard marker
-        spawnSync('pbcopy', { input: '__OPENCLI_WAITING__' });
-        // Wait for response, then read it
-        const pollInterval = 3;
+        // Restore clipboard after the prompt is sent.
+        if (clipBackup)
+            spawnSync('pbcopy', { input: clipBackup });
+        // Wait for response, then read the latest visible assistant message from the AX tree.
+        const pollInterval = 1;
         const maxPolls = Math.ceil(timeout / pollInterval);
         let response = '';
         for (let i = 0; i < maxPolls; i++) {
-            // Wait
             execSync(`sleep ${pollInterval}`);
-            // Try Cmd+Shift+C to copy the latest response
             execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-            execSync("osascript -e 'tell application \"System Events\" to keystroke \"c\" using {command down, shift down}'");
-            execSync("osascript -e 'delay 0.3'");
-            const copied = execSync('pbpaste', { encoding: 'utf-8' }).trim();
-            if (copied && copied !== '__OPENCLI_WAITING__' && copied !== text) {
-                response = copied;
+            execSync("osascript -e 'delay 0.2'");
+            const messagesNow = getVisibleChatMessages();
+            if (messagesNow.length <= messagesBefore.length)
+                continue;
+            const newMessages = messagesNow.slice(messagesBefore.length);
+            const candidate = [...newMessages].reverse().find((message) => message !== text);
+            if (candidate) {
+                response = candidate;
                 break;
             }
         }
-        // Restore clipboard
-        if (clipBackup)
-            spawnSync('pbcopy', { input: clipBackup });
         if (!response) {
             return [
                 { Role: 'User', Text: text },

package/dist/clis/chatgpt/ax.d.ts

@@ -0,0 +1 @@
+export declare function getVisibleChatMessages(): string[];

package/dist/clis/chatgpt/ax.js

@@ -0,0 +1,78 @@
+import { execFileSync } from 'node:child_process';
+const AX_READ_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func collectLists(_ el: AXUIElement, into out: inout [AXUIElement]) {
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == kAXListRole as String { out.append(el) }
+    for c in children(el) { collectLists(c, into: &out) }
+}
+
+func collectTexts(_ el: AXUIElement, into out: inout [String]) {
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == kAXStaticTextRole as String {
+        if let text = s(el, kAXDescriptionAttribute as String), !text.isEmpty {
+            out.append(text)
+        }
+    }
+    for c in children(el) { collectTexts(c, into: &out) }
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr)
+    exit(1)
+}
+
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr)
+    exit(1)
+}
+
+var lists: [AXUIElement] = []
+collectLists(win, into: &lists)
+
+var best: [String] = []
+for list in lists {
+    var texts: [String] = []
+    collectTexts(list, into: &texts)
+    if texts.count > best.count {
+        best = texts
+    }
+}
+
+let data = try! JSONSerialization.data(withJSONObject: best, options: [])
+print(String(data: data, encoding: .utf8)!)
+`;
+export function getVisibleChatMessages() {
+    const output = execFileSync('swift', ['-'], {
+        input: AX_READ_SCRIPT,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+    if (!output)
+        return [];
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.replace(/[\uFFFC\u200B-\u200D\uFEFF]/g, '').trim())
+        .filter((item) => item.length > 0);
+}

package/dist/clis/chatgpt/read.js

@@ -1,5 +1,6 @@
 import { execSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
+import { getVisibleChatMessages } from './ax.js';
 export const readCommand = cli({
     site: 'chatgpt',
     name: 'read',
@@ -12,14 +13,12 @@ export const readCommand = cli({
     func: async (page) => {
         try {
             execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-            execSync("osascript -e 'delay 0.5'");
-            execSync("osascript -e 'tell application \"System Events\" to keystroke \"c\" using {command down, shift down}'");
             execSync("osascript -e 'delay 0.3'");
-            const result = execSync('pbpaste', { encoding: 'utf-8' }).trim();
-            if (!result) {
-                return [{ Role: 'System', Text: 'No text was copied. Is there a response in the chat?' }];
+            const messages = getVisibleChatMessages();
+            if (!messages.length) {
+                return [{ Role: 'System', Text: 'No visible chat messages were found in the current ChatGPT window.' }];
             }
-            return [{ Role: 'Assistant', Text: result }];
+            return [{ Role: 'Assistant', Text: messages[messages.length - 1] }];
         }
         catch (err) {
             throw new Error("Failed to read from ChatGPT: " + err.message);

package/dist/clis/twitter/post.js

@@ -23,8 +23,15 @@ cli({
             const box = document.querySelector('[data-testid="tweetTextarea_0"]');
             if (box) {
                 box.focus();
-                // insertText is the most reliable way to trigger React's onChange events
-                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
+                // Simulate a paste event to properly handle newlines in Draft.js/React
+                const textToInsert = ${JSON.stringify(kwargs.text)};
+                const dataTransfer = new DataTransfer();
+                dataTransfer.setData('text/plain', textToInsert);
+                box.dispatchEvent(new ClipboardEvent('paste', {
+                    clipboardData: dataTransfer,
+                    bubbles: true,
+                    cancelable: true
+                }));
             } else {
                 return { ok: false, message: 'Could not find the tweet composer text area.' };
             }

package/dist/clis/twitter/search.js

@@ -20,45 +20,26 @@ cli({
         //    SPA navigation preserves the JS context, so the monkey-patched
         //    fetch will capture the SearchTimeline API call.
         await page.installInterceptor('SearchTimeline');
-        // 3. Use the search input to submit the query (SPA, no full reload).
-        //    Find the search input, type the query, and submit.
+        // 3. Trigger SPA navigation to search results via history API.
+        //    pushState + popstate triggers React Router's listener without
+        //    a full page reload, so the interceptor stays alive.
+        //    Note: the previous approach (nativeSetter + Enter keydown on the
+        //    search input) does not reliably trigger Twitter's form submission.
+        const searchUrl = JSON.stringify(`/search?q=${encodeURIComponent(query)}&f=top`);
         await page.evaluate(`
       (() => {
-        const input = document.querySelector('input[data-testid="SearchBox_Search_Input"]');
-        if (!input) throw new Error('Search input not found');
-        input.focus();
-        const nativeSetter = Object.getOwnPropertyDescriptor(
-          HTMLInputElement.prototype, 'value'
-        ).set;
-        nativeSetter.call(input, ${JSON.stringify(query)});
-        input.dispatchEvent(new Event('input', { bubbles: true }));
-      })()
-    `);
-        await page.wait(0.5);
-        // Press Enter to submit
-        await page.evaluate(`
-      (() => {
-        const input = document.querySelector('input[data-testid="SearchBox_Search_Input"]');
-        if (!input) throw new Error('Search input not found');
-        input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+        window.history.pushState({}, '', ${searchUrl});
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
       })()
     `);
         await page.wait(5);
-        // 4. Click "Top" tab if available (ensures we get top results)
-        try {
-            await page.evaluate(`
-        (() => {
-          const tabs = document.querySelectorAll('[role="tab"]');
-          for (const tab of tabs) {
-            if (tab.textContent.trim() === 'Top') { tab.click(); break; }
-          }
-        })()
-      `);
-            await page.wait(2);
+        // Verify SPA navigation succeeded
+        const currentPath = await page.evaluate('() => window.location.pathname');
+        if (!currentPath?.startsWith('/search')) {
+            throw new Error('SPA navigation to /search failed. Twitter may have changed its routing.');
         }
-        catch { /* ignore if tab not found */ }
-        // 5. Scroll to trigger additional pagination
-        await page.autoScroll({ times: 2, delayMs: 2000 });
+        // 4. Scroll to trigger additional pagination
+        await page.autoScroll({ times: 3, delayMs: 2000 });
         // 6. Retrieve captured data
         const requests = await page.getInterceptedRequests();
         if (!requests || requests.length === 0)

package/dist/clis/xiaohongshu/download.d.ts

@@ -2,6 +2,6 @@
  * Xiaohongshu download — download images and videos from a note.
  *
  * Usage:
- *   opencli xiaohongshu download --note-id abc123 --output ./xhs
+ *   opencli xiaohongshu download --note_id abc123 --output ./xhs
  */
 export {};

package/dist/clis/xiaohongshu/download.js

@@ -2,7 +2,7 @@
  * Xiaohongshu download — download images and videos from a note.
  *
  * Usage:
- *   opencli xiaohongshu download --note-id abc123 --output ./xhs
+ *   opencli xiaohongshu download --note_id abc123 --output ./xhs
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';

package/dist/engine.js

@@ -24,12 +24,15 @@ export async function discoverClis(...dirs) {
     // Fast path: try manifest first (production / post-build)
     for (const dir of dirs) {
         const manifestPath = path.resolve(dir, '..', 'cli-manifest.json');
-        if (fs.existsSync(manifestPath)) {
-            loadFromManifest(manifestPath, dir);
+        try {
+            await fs.promises.access(manifestPath);
+            await loadFromManifest(manifestPath, dir);
             continue; // Skip filesystem scan for this directory
         }
-        // Fallback: runtime filesystem scan (development)
-        await discoverClisFromFs(dir);
+        catch {
+            // Fallback: runtime filesystem scan (development)
+            await discoverClisFromFs(dir);
+        }
     }
 }
 /**
@@ -37,9 +40,10 @@ export async function discoverClis(...dirs) {
  * YAML pipelines are inlined — zero YAML parsing at runtime.
  * TS modules are deferred — loaded lazily on first execution.
  */
-function loadFromManifest(manifestPath, clisDir) {
+async function loadFromManifest(manifestPath, clisDir) {
     try {
-        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        const raw = await fs.promises.readFile(manifestPath, 'utf-8');
+        const manifest = JSON.parse(raw);
         for (const entry of manifest) {
             if (entry.type === 'yaml') {
                 // YAML pipelines fully inlined in manifest — register directly
@@ -90,17 +94,24 @@ function loadFromManifest(manifestPath, clisDir) {
  * Fallback: traditional filesystem scan (used during development with tsx).
  */
 async function discoverClisFromFs(dir) {
-    if (!fs.existsSync(dir))
+    try {
+        await fs.promises.access(dir);
+    }
+    catch {
         return;
+    }
     const promises = [];
-    for (const site of fs.readdirSync(dir)) {
+    const sites = await fs.promises.readdir(dir);
+    for (const site of sites) {
         const siteDir = path.join(dir, site);
-        if (!fs.statSync(siteDir).isDirectory())
+        const stat = await fs.promises.stat(siteDir);
+        if (!stat.isDirectory())
             continue;
-        for (const file of fs.readdirSync(siteDir)) {
+        const files = await fs.promises.readdir(siteDir);
+        for (const file of files) {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                registerYamlCli(filePath, site);
+                promises.push(registerYamlCli(filePath, site));
             }
             else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
@@ -112,9 +123,9 @@ async function discoverClisFromFs(dir) {
     }
     await Promise.all(promises);
 }
-function registerYamlCli(filePath, defaultSite) {
+async function registerYamlCli(filePath, defaultSite) {
     try {
-        const raw = fs.readFileSync(filePath, 'utf-8');
+        const raw = await fs.promises.readFile(filePath, 'utf-8');
         const def = yaml.load(raw);
         if (!def || typeof def !== 'object')
             return;

package/dist/explore.js

@@ -9,6 +9,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { DEFAULT_BROWSER_EXPLORE_TIMEOUT, browserSession, runWithTimeout } 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';
 // ── Site name detection ────────────────────────────────────────────────────
 const KNOWN_SITE_ALIASES = {
     'x.com': 'twitter', 'twitter.com': 'twitter',
@@ -134,11 +137,13 @@ function flattenFields(obj, prefix, maxDepth) {
     if (maxDepth <= 0 || !obj || typeof obj !== 'object')
         return [];
     const names = [];
-    for (const key of Object.keys(obj)) {
+    const record = obj;
+    for (const key of Object.keys(record)) {
         const full = prefix ? `${prefix}.${key}` : key;
         names.push(full);
-        if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key]))
-            names.push(...flattenFields(obj[key], full, maxDepth - 1));
+        const val = record[key];
+        if (val && typeof val === 'object' && !Array.isArray(val))
+            names.push(...flattenFields(val, full, maxDepth - 1));
     }
     return names;
 }
@@ -200,83 +205,11 @@ function inferStrategy(authIndicators) {
     return 'cookie';
 }
 // ── Framework detection ────────────────────────────────────────────────────
-const FRAMEWORK_DETECT_JS = `
-  () => {
-    const r = {};
-    try {
-      const app = document.querySelector('#app');
-      r.vue3 = !!(app && app.__vue_app__);
-      r.vue2 = !!(app && app.__vue__);
-      r.react = !!window.__REACT_DEVTOOLS_GLOBAL_HOOK__ || !!document.querySelector('[data-reactroot]');
-      r.nextjs = !!window.__NEXT_DATA__;
-      r.nuxt = !!window.__NUXT__;
-      if (r.vue3 && app.__vue_app__) { const gp = app.__vue_app__.config?.globalProperties; r.pinia = !!(gp && gp.$pinia); r.vuex = !!(gp && gp.$store); }
-    } catch {}
-    return r;
-  }
-`;
+const FRAMEWORK_DETECT_JS = detectFramework.toString();
 // ── Store discovery ────────────────────────────────────────────────────────
-const STORE_DISCOVER_JS = `
-  () => {
-    const stores = [];
-    try {
-      const app = document.querySelector('#app');
-      if (!app?.__vue_app__) return stores;
-      const gp = app.__vue_app__.config?.globalProperties;
-
-      // Pinia stores
-      const pinia = gp?.$pinia;
-      if (pinia?._s) {
-        pinia._s.forEach((store, id) => {
-          const actions = [];
-          const stateKeys = [];
-          for (const k in store) {
-            try {
-              if (k.startsWith('$') || k.startsWith('_')) continue;
-              if (typeof store[k] === 'function') actions.push(k);
-              else stateKeys.push(k);
-            } catch {}
-          }
-          stores.push({ type: 'pinia', id, actions: actions.slice(0, 20), stateKeys: stateKeys.slice(0, 15) });
-        });
-      }
-
-      // Vuex store modules
-      const vuex = gp?.$store;
-      if (vuex?._modules?.root?._children) {
-        const children = vuex._modules.root._children;
-        for (const [modName, mod] of Object.entries(children)) {
-          const actions = Object.keys(mod._rawModule?.actions ?? {}).slice(0, 20);
-          const stateKeys = Object.keys(mod.state ?? {}).slice(0, 15);
-          stores.push({ type: 'vuex', id: modName, actions, stateKeys });
-        }
-      }
-    } catch {}
-    return stores;
-  }
-`;
+const STORE_DISCOVER_JS = discoverStores.toString();
 // ── Auto-Interaction (Fuzzing) ─────────────────────────────────────────────
-const INTERACT_FUZZ_JS = `
-  async () => {
-    const sleep = ms => new Promise(r => setTimeout(r, ms));
-    const clickables = Array.from(document.querySelectorAll(
-      'button, [role="button"], [role="tab"], .tab, .btn, a[href="javascript:void(0)"], a[href="#"]'
-    )).slice(0, 15); // limit to 15 to avoid endless loops
-
-    let clicked = 0;
-    for (const el of clickables) {
-      try {
-        const rect = el.getBoundingClientRect();
-        if (rect.width > 0 && rect.height > 0) {
-          el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
-          clicked++;
-          await sleep(300); // give it time to trigger network
-        }
-      } catch {}
-    }
-    return clicked;
-  }
-`;
+const INTERACT_FUZZ_JS = interactFuzz.toString();
 // ── Main explore function ──────────────────────────────────────────────────
 export async function exploreUrl(url, opts) {
     const waitSeconds = opts.waitSeconds ?? 3.0;
@@ -286,25 +219,19 @@ export async function exploreUrl(url, opts) {
             // Step 1: Navigate
             await page.goto(url);
             await page.wait(waitSeconds);
-            // Step 2: Auto-scroll to trigger lazy loading (use keyboard since page.scroll may not exist)
-            for (let i = 0; i < 3; i++) {
-                try {
-                    await page.pressKey('End');
-                }
-                catch { }
-                await page.wait(1);
-            }
+            // Step 2: Auto-scroll to trigger lazy loading intelligently
+            await page.autoScroll({ times: 3, delayMs: 1500 }).catch(() => { });
             // Step 2.5: Interactive Fuzzing (if requested)
             if (opts.auto) {
                 try {
                     // First: targeted clicks by label (e.g. "字幕", "CC", "评论")
                     if (opts.clickLabels?.length) {
                         for (const label of opts.clickLabels) {
-                            const safeLabel = label.replace(/'/g, "\\'");
+                            const safeLabel = JSON.stringify(label);
                             await page.evaluate(`
                  (() => {
                    const el = [...document.querySelectorAll('button, [role="button"], [role="tab"], a, span')]
-                     .find(e => e.textContent && e.textContent.trim().includes('${safeLabel}'));
+                     .find(e => e.textContent && e.textContent.trim().includes(${safeLabel}));
                    if (el) el.click();
                  })()
                `);
@@ -324,11 +251,27 @@ export async function exploreUrl(url, opts) {
             // Step 4: Capture network traffic
             const rawNetwork = await page.networkRequests(false);
             const networkEntries = parseNetworkRequests(rawNetwork);
-            // Step 5: For JSON endpoints, re-fetch response body in-browser
-            const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200);
-            for (const ep of jsonEndpoints.slice(0, 10)) {
+            // Step 5: For JSON endpoints missing a body, carefully re-fetch in-browser via a pristine iframe
+            const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200 && !e.responseBody);
+            for (const ep of jsonEndpoints.slice(0, 5)) {
                 try {
-                    const body = await page.evaluate(`async () => { try { const r = await fetch(${JSON.stringify(ep.url)}, {credentials:'include'}); if (!r.ok) return null; const d = await r.json(); return JSON.stringify(d).slice(0,10000); } catch { return null; } }`);
+                    const body = await page.evaluate(`async () => {
+            let iframe = null;
+            try {
+              iframe = document.createElement('iframe');
+              iframe.style.display = 'none';
+              document.body.appendChild(iframe);
+              const cleanFetch = iframe.contentWindow.fetch || window.fetch;
+              const r = await cleanFetch(${JSON.stringify(ep.url)}, { credentials: 'include' });
+              if (!r.ok) return null;
+              const d = await r.json();
+              return JSON.stringify(d).slice(0, 10000);
+            } catch {
+              return null;
+            } finally {
+              if (iframe && iframe.parentNode) iframe.parentNode.removeChild(iframe);
+            }
+          }`);
                     if (body && typeof body === 'string') {
                         try {
                             ep.responseBody = JSON.parse(body);
@@ -443,7 +386,7 @@ export async function exploreUrl(url, opts) {
             const topStrategy = allAuth.has('signature') ? 'intercept' : allAuth.has('bearer') || allAuth.has('csrf') ? 'header' : allAuth.size === 0 ? 'public' : 'cookie';
             const siteName = opts.site ?? detectSiteName(metadata.url || url);
             const targetDir = opts.outDir ?? path.join('.opencli', 'explore', siteName);
-            fs.mkdirSync(targetDir, { recursive: true });
+            await fs.promises.mkdir(targetDir, { recursive: true });
             const result = {
                 site: siteName, target_url: url, final_url: metadata.url, title: metadata.title,
                 framework, stores, top_strategy: topStrategy,
@@ -452,24 +395,26 @@ export async function exploreUrl(url, opts) {
                 capabilities, auth_indicators: [...allAuth],
             };
             // Write artifacts
-            fs.writeFileSync(path.join(targetDir, 'manifest.json'), JSON.stringify({
+            const writeTasks = [];
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'manifest.json'), JSON.stringify({
                 site: siteName, target_url: url, final_url: metadata.url, title: metadata.title,
                 framework, stores: stores.map(s => ({ type: s.type, id: s.id, actions: s.actions })),
                 top_strategy: topStrategy, explored_at: new Date().toISOString(),
-            }, null, 2));
-            fs.writeFileSync(path.join(targetDir, 'endpoints.json'), JSON.stringify(analyzedEndpoints.map(ep => ({
+            }, null, 2)));
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'endpoints.json'), JSON.stringify(analyzedEndpoints.map(ep => ({
                 pattern: ep.pattern, method: ep.method, url: ep.url, status: ep.status,
                 contentType: ep.contentType, score: ep.score, queryParams: ep.queryParams,
                 itemPath: ep.responseAnalysis?.itemPath ?? null, itemCount: ep.responseAnalysis?.itemCount ?? 0,
                 detectedFields: ep.responseAnalysis?.detectedFields ?? {}, authIndicators: ep.authIndicators,
-            })), null, 2));
-            fs.writeFileSync(path.join(targetDir, 'capabilities.json'), JSON.stringify(capabilities, null, 2));
-            fs.writeFileSync(path.join(targetDir, 'auth.json'), JSON.stringify({
+            })), null, 2)));
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'capabilities.json'), JSON.stringify(capabilities, null, 2)));
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'auth.json'), JSON.stringify({
                 top_strategy: topStrategy, indicators: [...allAuth], framework,
-            }, null, 2));
+            }, null, 2)));
             if (stores.length > 0) {
-                fs.writeFileSync(path.join(targetDir, 'stores.json'), JSON.stringify(stores, null, 2));
+                writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'stores.json'), JSON.stringify(stores, null, 2)));
             }
+            await Promise.all(writeTasks);
             return { ...result, out_dir: targetDir };
         })(), { timeout: exploreTimeout, label: `Explore ${url}` });
     });