@aggroot-team/aggroot 1.7.2

package/scripts/generate-example-skills.ts

@@ -0,0 +1,238 @@
+/**
+ * 生成示例 Skills 到桌面（带分类目录 + DESCRIPTION.md + 索引缓存）
+ *
+ * 运行: npx tsx scripts/generate-example-skills.ts
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createSkillManageTool } from '../src/domain/skill/skill-manager-tool.js';
+import { createSkillRegistry, loadSkillsWithCache, invalidateIndexCache } from '../src/domain/skill/skill-loader.js';
+
+const outputDir = path.join(os.homedir(), 'Desktop', 'generated-skills');
+fs.mkdirSync(outputDir, { recursive: true });
+process.env.AGGROOT_HOME = outputDir;
+
+const registry = createSkillRegistry();
+const tool = createSkillManageTool(registry);
+
+const skills: Array<{ name: string; category?: string; content: string }> = [
+  // ---- devops 分类 ----
+  {
+    name: 'deploy-to-staging',
+    category: 'devops',
+    content: `---
+name: deploy-to-staging
+description: Deploy the project to staging environment using docker
+whenToUse: When you need to deploy the current project to the staging server
+---
+
+# Deploy to Staging
+
+1. Run tests: \`npm test\`
+2. Build Docker image: \`docker build -t myapp:staging .\`
+3. Push to registry: \`docker push registry.example.com/myapp:staging\`
+4. SSH to staging server: \`ssh deploy@staging.example.com\`
+5. Pull and restart: \`docker-compose pull && docker-compose up -d\`
+6. Verify: \`curl -f https://staging.example.com/health\`
+
+## Pitfalls
+- Always run tests before deploying
+- Check that .env.staging has the correct DATABASE_URL
+- If health check fails, rollback with \`docker-compose down && docker-compose up -d --no-pull\`
+`,
+  },
+  {
+    name: 'rollback',
+    category: 'devops',
+    content: `---
+name: rollback
+description: Rollback a deployment to the previous version
+whenToUse: When a deployment fails or causes issues in production
+---
+
+# Rollback Deployment
+
+1. Check current version: \`docker-compose ps\`
+2. Rollback to previous image: \`docker-compose down && docker-compose up -d --no-pull\`
+3. Verify health: \`curl -f https://staging.example.com/health\`
+4. Notify team in Slack
+
+## Pitfalls
+- Always verify the previous image is still available
+- Don't rollback if database migration already ran
+`,
+  },
+  // ---- debugging 分类 ----
+  {
+    name: 'debug-auth-401',
+    category: 'debugging',
+    content: `---
+name: debug-auth-401
+description: Debug and fix 401 authentication errors in test suites
+whenToUse: When auth tests fail with 401 status code
+---
+
+# Debug Auth 401 Errors
+
+1. Run the failing test with verbose output to identify which test and assertion failed
+2. Read the auth middleware source code to understand the token validation logic
+3. Check if the middleware correctly handles token formats (e.g., Bearer prefix stripping)
+4. Fix the middleware to properly extract the token
+5. Re-run tests to verify the fix
+
+## Common Causes
+- Middleware not stripping "Bearer " prefix from Authorization header
+- Missing or incorrect token extraction logic
+- Token not being passed in test fixtures
+`,
+  },
+  {
+    name: 'debug-memory-leak',
+    category: 'debugging',
+    content: `---
+name: debug-memory-leak
+description: Investigate and fix memory leaks in Node.js applications
+whenToUse: When the application shows increasing memory usage over time
+---
+
+# Debug Memory Leak
+
+1. Take heap snapshot: \`node --inspect app.js\` then Chrome DevTools → Memory → Take Snapshot
+2. Compare snapshots over time to find growing objects
+3. Check for common patterns: event listeners not removed, closures holding references, global caches
+4. Fix the leak and verify with load testing
+
+## Common Causes
+- Event listeners not removed on cleanup
+- Closures capturing large objects
+- Unbounded caches without TTL
+`,
+  },
+  // ---- git 分类 ----
+  {
+    name: 'smart-commit',
+    category: 'git',
+    content: `---
+name: smart-commit
+description: Create a well-structured git commit with proper message
+whenToUse: When you need to commit changes to git
+---
+
+# Smart Commit
+
+1. Run \`git status\` to see all changes
+2. Run \`git diff\` to understand what changed
+3. Stage appropriate files with \`git add\`
+4. Create commit with conventional commit format:
+   - feat: new feature
+   - fix: bug fix
+   - refactor: code refactoring
+
+## Pitfalls
+- Always review the diff before committing
+- Never commit .env files or secrets
+`,
+  },
+  // ---- 根级 skill（无分类）----
+  {
+    name: 'explain',
+    content: `---
+name: explain
+description: Explain code or concept in detail
+whenToUse: When you need to understand how something works
+---
+
+# Explain
+
+1. Read the relevant source files
+2. Trace the execution flow
+3. Summarize the key concepts
+4. Provide examples if helpful
+
+Provide explanation at the requested detail level.
+`,
+  },
+];
+
+console.log('Generating skills with category structure...\n');
+
+for (const skill of skills) {
+  const result = await tool.execute({
+    action: 'create',
+    name: skill.name,
+    content: skill.content,
+    category: skill.category,
+  });
+
+  if (result.success) {
+    console.log(`  ✓ ${skill.name}${skill.category ? ` (category: ${skill.category})` : ''}`);
+  } else {
+    console.log(`  ✗ ${skill.name}: ${result.stderr}`);
+  }
+}
+
+// 手动写 DESCRIPTION.md 文件到分类目录
+const skillsDir = path.join(outputDir, 'skills');
+const descriptions: Record<string, string> = {
+  devops: 'DevOps tools — deployment, rollback, and infrastructure management',
+  debugging: 'Debugging workflows — systematic approaches to finding and fixing bugs',
+  git: 'Git workflows — commit, branch, and version control best practices',
+};
+
+for (const [cat, desc] of Object.entries(descriptions)) {
+  const descPath = path.join(skillsDir, cat, 'DESCRIPTION.md');
+  if (fs.existsSync(path.join(skillsDir, cat))) {
+    fs.writeFileSync(descPath, `---\ndescription: ${desc}\n---\n`, 'utf-8');
+    console.log(`  ✓ ${cat}/DESCRIPTION.md`);
+  }
+}
+
+// 删除旧缓存并重新加载以生成 .index.json
+await invalidateIndexCache(skillsDir);
+
+console.log('\nLoading skills with cache...');
+const { skills: loadedSkills, categories } = await loadSkillsWithCache(skillsDir, 'user');
+
+console.log(`\nLoaded ${loadedSkills.length} skills, ${categories.size} categories:`);
+for (const [cat, desc] of categories) {
+  console.log(`  ${cat}: ${desc}`);
+}
+
+// 验证 .index.json
+const indexPath = path.join(skillsDir, '.index.json');
+if (fs.existsSync(indexPath)) {
+  const cache = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+  console.log(`\n.index.json created:`);
+  console.log(`  version: ${cache.version}`);
+  console.log(`  skills: ${cache.skills.length}`);
+  console.log(`  categories: ${Object.keys(cache.categories).join(', ')}`);
+  console.log(`  manifest entries: ${Object.keys(cache.manifest).length}`);
+  for (const entry of cache.skills) {
+    console.log(`    - ${entry.name} (category: ${entry.category || 'none'}, path: ${entry.filePath})`);
+  }
+}
+
+// 列出生成的文件结构
+function listFiles(dir: string, prefix = ''): void {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith('.') && entry.isFile()) {
+      // Show dot files (like .index.json) but with indicator
+      console.log(`${prefix}${entry.name} (cache)`);
+      continue;
+    }
+    if (entry.name.startsWith('.')) continue;
+    if (entry.isDirectory()) {
+      console.log(`${prefix}${entry.name}/`);
+      listFiles(path.join(dir, entry.name), `${prefix}  `);
+    } else {
+      console.log(`${prefix}${entry.name}`);
+    }
+  }
+}
+
+console.log('\nGenerated file structure:');
+listFiles(skillsDir);
+
+console.log(`\nOutput directory: ${outputDir}`);

package/scripts/import-meta-shim.js

@@ -0,0 +1,3 @@
+// Shim for import.meta.url in CJS bundle
+// esbuild will inject this when using format: 'cjs'
+export const __dirname_url__ = require('url').pathToFileURL(__filename).href;

package/scripts/install-browsers.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+import { spawn } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const MIRRORS = [
+  { host: "https://npmmirror.com/mirrors/playwright", name: "淘宝镜像" },
+  { host: "", name: "官方源" },
+];
+
+// npm postinstall 会吞掉 stdout，用 stderr 输出状态让用户看到
+function status(msg) {
+  process.stderr.write(`\n[browsers] ${msg}\n`);
+}
+
+/**
+ * 获取当前 playwright 包需要的 chromium 版本号
+ * 从 playwright-core 的 registry 中读取
+ */
+function getRequiredChromiumVersion() {
+  try {
+    // 尝试从 playwright-core 的 registry 文件读取
+    const registryPaths = [
+      join(import.meta.url.replace('file:///', '').replace(/\/scripts\/.*/, ''), 'node_modules', 'playwright-core', 'browsers.json'),
+      join(process.cwd(), 'node_modules', 'playwright-core', 'browsers.json'),
+    ];
+
+    // 也检查全局安装路径
+    const globalPaths = [
+      join(homedir(), 'AppData', 'Roaming', 'npm', 'node_modules', 'aggroot', 'node_modules', 'playwright-core', 'browsers.json'),
+      join('/usr', 'local', 'lib', 'node_modules', 'aggroot', 'node_modules', 'playwright-core', 'browsers.json'),
+    ];
+
+    for (const p of [...registryPaths, ...globalPaths]) {
+      const filePath = p.startsWith('/') ? p : p.replace(/\//g, '\\');
+      if (existsSync(filePath)) {
+        const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+        const chromium = data.browsers?.find(b => b.name === 'chromium');
+        if (chromium?.revision) return chromium.revision;
+      }
+    }
+  } catch { /* fallback to npx */ }
+  return null;
+}
+
+/**
+ * 检查 Playwright Chromium 浏览器是否已安装且版本匹配
+ */
+function isChromiumInstalled() {
+  const playwrightDir = process.platform === 'win32'
+    ? join(homedir(), 'AppData', 'Local', 'ms-playwright')
+    : join(homedir(), '.cache', 'ms-playwright');
+
+  if (!existsSync(playwrightDir)) return false;
+
+  // 查找已安装的 chromium 目录
+  const dirs = readdirSync(playwrightDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name.startsWith('chromium-'))
+    .map(d => d.name);
+
+  if (dirs.length === 0) return false;
+
+  // 检查是否有可执行文件
+  const latestDir = dirs.sort().pop();
+  const exeName = process.platform === 'win32' ? 'chrome.exe' : 'chrome';
+  const possiblePaths = [
+    join(playwrightDir, latestDir, 'chrome-win64', exeName),
+    join(playwrightDir, latestDir, 'chrome-linux', exeName),
+    join(playwrightDir, latestDir, 'chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium'),
+  ];
+
+  return possiblePaths.some(p => existsSync(p));
+}
+
+function tryInstall(mirror) {
+  return new Promise((resolve) => {
+    const env = { ...process.env };
+    if (mirror.host) {
+      env.PLAYWRIGHT_DOWNLOAD_HOST = mirror.host;
+    } else {
+      delete env.PLAYWRIGHT_DOWNLOAD_HOST;
+    }
+
+    status(`正在下载 Playwright Chromium (${mirror.name})...`);
+
+    const child = spawn("npx", ["playwright", "install", "chromium"], {
+      stdio: "inherit",
+      shell: true,
+      env,
+    });
+
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, 120000);
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve(timedOut ? "timeout" : code);
+    });
+
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve("error");
+    });
+  });
+}
+
+(async () => {
+  // 先检查是否已安装
+  if (isChromiumInstalled()) {
+    status("Playwright Chromium 已安装，跳过下载。");
+    return;
+  }
+
+  status("Playwright Chromium 未安装，开始下载...");
+
+  for (const mirror of MIRRORS) {
+    const result = await tryInstall(mirror);
+    if (result === 0) {
+      status("浏览器安装完成。");
+      return;
+    }
+    if (mirror === MIRRORS[0]) {
+      status(`${mirror.name}下载失败，尝试${MIRRORS[1].name}...`);
+    }
+  }
+  status("浏览器安装失败，将在首次使用时自动下载。");
+})();

package/scripts/obfuscate.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+/**
+ * Bundle dist/ into a single file using esbuild.
+ *
+ * Strategy:
+ * 1. tsc compiles TS → JS (no source maps, no declarations)
+ * 2. esbuild bundles + minifies all JS into dist/index.cjs
+ *    - All variable names shortened
+ *    - All whitespace removed
+ *    - Dead code eliminated
+ *    - No directory structure visible
+ *    - No file names visible
+ *
+ * esbuild minification alone provides strong protection:
+ * - Variables become single-letter names (a, b, c...)
+ * - All comments and formatting stripped
+ * - Original module structure completely flattened
+ * - No source maps, no type declarations
+ */
+
+import * as esbuild from 'esbuild';
+import { readFileSync, writeFileSync, readdirSync, rmSync, statSync, copyFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+const DIST_DIR = join(process.cwd(), 'dist');
+const ENTRY = join(DIST_DIR, 'index.js');
+const BUNDLE_OUTPUT = join(DIST_DIR, 'index.bundled.js');
+
+// Step 1: Bundle with esbuild
+console.log('[bundle] Bundling with esbuild...');
+
+try {
+  const result = await esbuild.build({
+    entryPoints: [ENTRY],
+    bundle: true,
+    platform: 'node',
+    target: 'node20',
+    format: 'cjs',
+    outfile: BUNDLE_OUTPUT,
+    // Replace import.meta.url with CJS equivalent
+    define: {
+      'import.meta.url': '__dirname_url__',
+    },
+    // Inject __dirname_url__ variable
+    inject: [join(process.cwd(), 'scripts', 'import-meta-shim.js')],
+    external: [
+      'sharp',
+      'playwright',
+      '@xenova/transformers',
+      'tiktoken',
+      'yoga-layout',
+      // Heavy dependencies externalized for faster startup
+      'pino-pretty',
+      'docx',
+      'exceljs',
+      'mammoth',
+      'pptxgenjs',
+      'openai',
+      // bindings is only used by better-sqlite3's fallback path (when nativeBinding is not provided)
+      // We always provide nativeBinding, so bindings is never actually called at runtime
+      'bindings',
+    ],
+    minify: true,
+    legalComments: 'none',
+    treeShaking: true,
+    metafile: true,
+  });
+
+  if (result.metafile) {
+    console.log(`[bundle] Input: ${Object.keys(result.metafile.inputs).length} modules`);
+  }
+  const outputSize = statSync(BUNDLE_OUTPUT).size;
+  console.log(`[bundle] Output: ${(outputSize / 1024).toFixed(0)} KB`);
+} catch (error) {
+  console.error('[bundle] Failed:', error.message);
+  process.exit(1);
+}
+
+// Step 1.5: Copy WASM files to dist/ (esbuild cannot bundle binary .wasm files)
+const WASM_FILES = [
+  { src: 'web-tree-sitter/web-tree-sitter.wasm', dest: 'web-tree-sitter.wasm' },
+  { src: 'tree-sitter-cpp/tree-sitter-cpp.wasm', dest: 'tree-sitter-cpp.wasm' },
+  { src: 'tree-sitter-c/tree-sitter-c.wasm', dest: 'tree-sitter-c.wasm' },
+];
+
+for (const { src, dest } of WASM_FILES) {
+  const srcPath = join(process.cwd(), 'node_modules', src);
+  const destPath = join(DIST_DIR, dest);
+  if (existsSync(srcPath)) {
+    copyFileSync(srcPath, destPath);
+    console.log(`[bundle] Copied WASM: ${dest}`);
+  } else {
+    console.warn(`[bundle] WASM not found: ${src}`);
+  }
+}
+
+// Step 1.6: Copy pre-compiled native modules to dist/native/
+// This avoids requiring users to have C++ build tools installed
+const NATIVE_DIR = join(DIST_DIR, 'native');
+const NATIVE_MODULES = [
+  { src: 'better-sqlite3/build/Release/better_sqlite3.node', dest: 'better_sqlite3.node' },
+];
+
+if (!existsSync(NATIVE_DIR)) {
+  mkdirSync(NATIVE_DIR, { recursive: true });
+}
+
+for (const { src, dest } of NATIVE_MODULES) {
+  const srcPath = join(process.cwd(), 'node_modules', src);
+  const destPath = join(NATIVE_DIR, dest);
+  if (existsSync(srcPath)) {
+    try {
+      copyFileSync(srcPath, destPath);
+      console.log(`[bundle] Copied native: ${dest}`);
+    } catch (err) {
+      console.warn(`[bundle] Failed to copy native module ${dest}: ${err.code} — using existing file if present`);
+    }
+  } else {
+    // pnpm hoists native binaries into .pnpm store; the top-level node_modules
+    // symlink may have an empty build/ directory. Search the store directly.
+    let found = false;
+    const pnpmDir = join(process.cwd(), 'node_modules', '.pnpm');
+    if (existsSync(pnpmDir)) {
+      const entries = readdirSync(pnpmDir).filter(d => d.startsWith('better-sqlite3'));
+      for (const ver of entries) {
+        const candidate = join(pnpmDir, ver, 'node_modules', 'better-sqlite3', 'build', 'Release', 'better_sqlite3.node');
+        if (existsSync(candidate)) {
+          try {
+            copyFileSync(candidate, destPath);
+            console.log(`[bundle] Copied native: ${dest} (from pnpm store: ${ver})`);
+            found = true;
+            break;
+          } catch (err) {
+            console.warn(`[bundle] Failed to copy native module ${dest}: ${err.code}`);
+          }
+        }
+      }
+    }
+    if (!found) {
+      console.warn(`[bundle] Native module not found: ${src} — users will need build tools`);
+    }
+  }
+}
+
+// Step 2: Remove original directory structure
+console.log('[bundle] Cleaning up original files...');
+
+const filesToKeep = new Set(['index.bundled.js', 'web-tree-sitter.wasm', 'tree-sitter-cpp.wasm', 'tree-sitter-c.wasm', 'cli.cjs']);
+const dirsToKeep = new Set(['native']);
+
+function cleanDir(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!dirsToKeep.has(entry.name)) {
+        rmSync(fullPath, { recursive: true, force: true });
+      }
+    } else if (!filesToKeep.has(entry.name)) {
+      rmSync(fullPath, { force: true });
+    }
+  }
+}
+cleanDir(DIST_DIR);
+
+// Step 3: Fix shebang and write final file
+// Remove shebang from bundle body (it gets displaced by processing)
+let bundleContent = readFileSync(BUNDLE_OUTPUT, 'utf-8');
+if (bundleContent.startsWith('#!')) {
+  bundleContent = bundleContent.substring(bundleContent.indexOf('\n') + 1);
+}
+
+const finalPath = join(DIST_DIR, 'index.cjs');
+writeFileSync(finalPath, '#!/usr/bin/env node\n' + bundleContent, 'utf-8');
+rmSync(BUNDLE_OUTPUT, { force: true });
+
+const finalSize = statSync(finalPath).size;
+console.log(`[bundle] Done: dist/index.cjs (${(finalSize / 1024).toFixed(0)} KB)`);
+console.log('[bundle] Complete — single minified file, no source exposure');
+
+// Step 4: Generate CLI wrapper that sets --max-old-space-size=4096
+// The shebang #!/usr/bin/env node cannot pass flags, so we need a wrapper
+// that re-spawns node with the larger heap limit when needed.
+// Use .cjs extension so Node treats it as CommonJS regardless of package.json "type"
+const cliWrapperPath = join(DIST_DIR, 'cli.cjs');
+const cliWrapperContent = `#!/usr/bin/env node
+// AggRoot CLI wrapper - ensures Node.js heap is large enough for long sessions.
+const v8 = require('node:v8');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const heapLimitMB = Math.round(v8.getHeapStatistics().heap_size_limit / 1024 / 1024);
+
+if (heapLimitMB < 3500 && !process.env.AGGROOT_SPAWNED) {
+  // Re-spawn with larger heap, inheriting stdio for seamless UX
+  const child = spawn(process.execPath, [
+    '--max-old-space-size=4096',
+    '--no-warnings',
+    path.resolve(__dirname, 'index.cjs'),
+    ...process.argv.slice(2),
+  ], {
+    stdio: 'inherit',
+    env: { ...process.env, AGGROOT_SPAWNED: '1' },
+  });
+  child.on('error', (err) => {
+    console.error('Failed to re-spawn with larger heap:', err.message);
+    process.exit(1);
+  });
+  child.on('exit', (code) => process.exit(code ?? 0));
+} else {
+  require('./index.cjs');
+}
+`;
+writeFileSync(cliWrapperPath, cliWrapperContent, 'utf-8');
+console.log(`[bundle] CLI wrapper: dist/cli.cjs`);

package/scripts/test-bash-parser.ts

@@ -0,0 +1,37 @@
+import { parseSource } from '../src/shared/utils/bash-parser.ts';
+import { isSafeShellCommand } from '../src/domain/agent/services/approval.ts';
+import { getToolRiskLevel, ToolRiskLevel } from '../src/domain/agent/services/approval.ts';
+
+const commands = [
+  'cd /c/Users/zhuoz/Desktop/gui && ls -la build* 2>/dev/null || echo "No build directory found"',
+  'cd C:/Users/zhuoz/Desktop/gui && find build -name "libAutoJdv*" -o -name "AutoJdv.dll" 2>/dev/null | head -5',
+  'ls -la',
+  'echo hello',
+];
+
+for (const cmd of commands) {
+  console.log(`\n=== Testing: ${cmd.slice(0, 80)}... ===`);
+
+  const t0 = Date.now();
+  let astResult;
+  try {
+    astResult = parseSource(cmd);
+  } catch (e) {
+    console.log('parseSource THREW:', e);
+    continue;
+  }
+  const parseTime = Date.now() - t0;
+  console.log(`parseSource: type=${astResult?.type} children=${astResult?.children?.length} time=${parseTime}ms`);
+
+  const t1 = Date.now();
+  const safe = isSafeShellCommand(cmd);
+  const safeTime = Date.now() - t1;
+  console.log(`isSafeShellCommand: ${safe} time=${safeTime}ms`);
+
+  const t2 = Date.now();
+  const risk = getToolRiskLevel('Shell', { command: cmd });
+  const riskTime = Date.now() - t2;
+  console.log(`getToolRiskLevel: ${risk} time=${riskTime}ms`);
+}
+
+console.log('\nAll tests completed.');

package/scripts/test-parser2.ts

@@ -0,0 +1,24 @@
+import { parseSource } from '../src/shared/utils/bash-parser.ts';
+
+const cmd = 'cd /c/Users/zhuoz/Desktop/gui && ls -la build* 2>/dev/null || echo "No build directory found"';
+
+// Test 1: just parseSource with timeout guard
+console.log('Testing parseSource...');
+const start = Date.now();
+
+// Use a worker-like approach: run in a separate microtask with a hard timeout
+let result: any = 'TIMEOUT';
+let done = false;
+
+// We can't truly timeout sync code in JS, but let's at least see if it returns
+try {
+  result = parseSource(cmd);
+  done = true;
+} catch (e) {
+  result = 'ERROR: ' + e;
+  done = true;
+}
+
+const elapsed = Date.now() - start;
+console.log('parseSource returned:', done ? 'yes' : 'no', 'time:', elapsed, 'ms');
+console.log('result type:', result?.type, 'children:', result?.children?.length);

package/scripts/test-parser3.js

@@ -0,0 +1,4 @@
+// Test: find where the bash parser infinite loop is
+// by testing parseSource with a simpler version of the command
+
+const { parseSource } = require('../dist/shared/utils/bash-parser.cjs');