tribunal-kit 5.8.5 → 6.0.1

package/dist/commands/memory.js

@@ -31,6 +31,43 @@ const PROJECTION_FILE = 'MEMORY.md';
 const MAX_ENTRIES = 500;
 const EPISODIC_TTL_DAYS = 30;
 
+function acquireLock(agentDest) {
+    const lockPath = getIndexPath(agentDest) + '.lock';
+    const maxRetries = 10;
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            const fd = fs_1.default.openSync(lockPath, 'wx');
+            fs_1.default.closeSync(fd);
+            return lockPath;
+        } catch (err) {
+            if (err.code !== 'EEXIST') {
+                throw err;
+            }
+            // Non-blocking sleep — avoids busy-wait event loop blocking
+            const waitBuf = new Int32Array(new SharedArrayBuffer(4));
+            Atomics.wait(waitBuf, 0, 0, 50);
+        }
+    }
+    try {
+        const stats = fs_1.default.statSync(lockPath);
+        if (Date.now() - stats.mtimeMs > 10000) {
+            fs_1.default.unlinkSync(lockPath);
+            const fd = fs_1.default.openSync(lockPath, 'wx');
+            fs_1.default.closeSync(fd);
+            return lockPath;
+        }
+    } catch {}
+    throw new Error('Could not acquire lock for memory index');
+}
+
+function releaseLock(lockPath) {
+    try {
+        if (lockPath && fs_1.default.existsSync(lockPath)) {
+            fs_1.default.unlinkSync(lockPath);
+        }
+    } catch {}
+}
+
 function getMemoryDir(agentDest) {
     return path_1.default.join(agentDest, MEMORY_DIR);
 }
@@ -121,95 +158,110 @@ function memoryStore(agentDest, type, content, tags, sessionId) {
         throw new Error('Memory content cannot be empty');
     }
 
-    const index = loadIndex(agentDest);
+    const lockPath = acquireLock(agentDest);
+    try {
+        const index = loadIndex(agentDest);
 
-    // Enforce cap — auto-GC if needed
-    if (index.entries.length >= MAX_ENTRIES) {
-        index.entries = index.entries.filter(e => e.memory_type !== 'working');
-        if (index.entries.length >= MAX_ENTRIES) {
-            index.entries = index.entries.filter(e => {
-                if (e.memory_type === 'episodic') {
-                    return daysSince(e.created_at) < EPISODIC_TTL_DAYS;
-                }
-                return true;
-            });
-        }
+        // Enforce cap — auto-GC if needed
         if (index.entries.length >= MAX_ENTRIES) {
-            throw new Error(`Memory at capacity (${MAX_ENTRIES}). Run: tk memory gc`);
+            index.entries = index.entries.filter(e => e.memory_type !== 'working');
+            if (index.entries.length >= MAX_ENTRIES) {
+                index.entries = index.entries.filter(e => {
+                    if (e.memory_type === 'episodic') {
+                        return daysSince(e.created_at) < EPISODIC_TTL_DAYS; // Typo correction or TTL match
+                    }
+                    return true;
+                });
+            }
+            if (index.entries.length >= MAX_ENTRIES) {
+                throw new Error(`Memory at capacity (${MAX_ENTRIES}). Run: tk memory gc`);
+            }
         }
-    }
 
-    const now = nowEpochStr();
-    const id = index.next_id || (index.entries.length > 0 ? Math.max(...index.entries.map(e => e.id)) + 1 : 1);
-    const entry = {
-        id,
-        memory_type: type,
-        content: content.trim(),
-        tags: tags.filter(t => t.length > 0),
-        created_at: now,
-        last_accessed: now,
-        access_count: 0,
-        token_estimate: estimateTokens(content),
-        source: type === 'working' ? 'session' : 'manual',
-        session_id: sessionId || null,
-    };
-
-    index.entries.push(entry);
-    index.next_id = id + 1;
-    saveIndex(agentDest, index);
-    generateProjection(agentDest, index);
-
-    return { id, token_estimate: entry.token_estimate };
+        const now = nowEpochStr();
+        const id = index.next_id || (index.entries.length > 0 ? Math.max(...index.entries.map(e => e.id)) + 1 : 1);
+        const entry = {
+            id,
+            memory_type: type,
+            content: content.trim(),
+            tags: tags.filter(t => t.length > 0),
+            created_at: now,
+            last_accessed: now,
+            access_count: 0,
+            token_estimate: estimateTokens(content),
+            source: type === 'working' ? 'session' : 'manual',
+            session_id: sessionId || null,
+        };
+
+        index.entries.push(entry);
+        index.next_id = id + 1;
+        saveIndex(agentDest, index);
+        generateProjection(agentDest, index);
+
+        return { id, token_estimate: entry.token_estimate };
+    } finally {
+        releaseLock(lockPath);
+    }
 }
 
 // ── Recall ──────────────────────────────────────────────────────────────────
 
 function memoryRecall(agentDest, query, budget = 2000) {
-    const index = loadIndex(agentDest);
-
-    const scored = index.entries
-        .map(entry => ({ entry, score: computeScore(entry, query) }))
-        .filter(s => s.score > 0)
-        .sort((a, b) => b.score - a.score);
+    const lockPath = acquireLock(agentDest);
+    try {
+        const index = loadIndex(agentDest);
+
+        const scored = index.entries
+            .map(entry => ({ entry, score: computeScore(entry, query) }))
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score);
+
+        let totalTokens = 0;
+        const results = [];
+
+        for (const { entry, score } of scored) {
+            if (totalTokens + entry.token_estimate > budget) break;
+            totalTokens += entry.token_estimate;
+            entry.last_accessed = nowEpochStr();
+            entry.access_count = (entry.access_count || 0) + 1;
+            results.push({ ...entry, score });
+        }
 
-    let totalTokens = 0;
-    const results = [];
+        // Save updated access counts
+        saveIndex(agentDest, index);
 
-    for (const { entry, score } of scored) {
-        if (totalTokens + entry.token_estimate > budget) break;
-        totalTokens += entry.token_estimate;
-        entry.last_accessed = nowEpochStr();
-        entry.access_count = (entry.access_count || 0) + 1;
-        results.push({ ...entry, score });
+        return { results, tokens_used: totalTokens, budget };
+    } finally {
+        releaseLock(lockPath);
     }
-
-    // Save updated access counts
-    saveIndex(agentDest, index);
-
-    return { results, tokens_used: totalTokens, budget };
 }
 
 // ── Garbage Collect ─────────────────────────────────────────────────────────
 
 function memoryGc(agentDest) {
-    const index = loadIndex(agentDest);
-    const before = index.entries.length;
+    const lockPath = acquireLock(agentDest);
+    try {
+        const index = loadIndex(agentDest);
+        const before = index.entries.length;
 
-    let workingRemoved = 0;
-    let episodicRemoved = 0;
+        let workingRemoved = 0;
+        let episodicRemoved = 0;
 
-    index.entries = index.entries.filter(e => {
-        if (e.memory_type === 'working') { workingRemoved++; return false; }
-        if (e.memory_type === 'episodic' && daysSince(e.created_at) >= EPISODIC_TTL_DAYS) {
-            episodicRemoved++; return false;
-        }
-        return true;
-    });
+        index.entries = index.entries.filter(e => {
+            if (e.memory_type === 'working') { workingRemoved++; return false; }
+            if (e.memory_type === 'episodic' && daysSince(e.created_at) >= EPISODIC_TTL_DAYS) {
+                episodicRemoved++; return false;
+            }
+            return true;
+        });
 
-    saveIndex(agentDest, index);
-    generateProjection(agentDest, index);
+        saveIndex(agentDest, index);
+        generateProjection(agentDest, index);
 
-    return { working_removed: workingRemoved, episodic_removed: episodicRemoved, before, after: index.entries.length };
+        return { working_removed: workingRemoved, episodic_removed: episodicRemoved, before, after: index.entries.length };
+    } finally {
+        releaseLock(lockPath);
+    }
 }
 
 // ── Stats ───────────────────────────────────────────────────────────────────

package/dist/commands/minimal.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdMinimal = cmdMinimal;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const helpers_1 = require("../utils/helpers");
+
+function cmdMinimal(flags, quiet = false) {
+    const targetDir = flags.path ? path_1.default.resolve(flags.path) : process.cwd();
+    const agentDest = path_1.default.join(targetDir, '.agent');
+    (0, helpers_1.banner)(quiet);
+
+    if (!fs_1.default.existsSync(agentDest)) {
+        (0, logger_1.log)(`  ${(0, logger_1.c)('red', '✖')} ${(0, logger_1.bold)('Not installed')} in this project`);
+        return;
+    }
+
+    const enginePath = path_1.default.join(agentDest, 'scripts', 'minimal_change_engine.js');
+    if (!fs_1.default.existsSync(enginePath)) {
+        (0, logger_1.log)(`  ${(0, logger_1.c)('red', '✖')} minimal_change_engine.js not found`);
+        return;
+    }
+
+    try {
+        const engine = require(enginePath);
+        const task = flags.task || flags._?.slice(1).join(' ') || 'Default task evaluation';
+        const mode = flags.mode || 'balanced';
+        const result = engine.evaluateMinimalChange(task, {
+            files_added: flags.filesAdded ? parseInt(flags.filesAdded, 10) : 0,
+            files_modified: flags.filesModified ? parseInt(flags.filesModified, 10) : 1,
+            estimated_lines_added: flags.linesAdded ? parseInt(flags.linesAdded, 10) : 20,
+        }, { mode, cwd: targetDir });
+
+        if (flags.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+
+        (0, logger_1.log)(`  ${(0, logger_1.bold)('Minimal Change Governance Audit')}`);
+        (0, logger_1.log)(`  Minimality Score:          ${result.passed ? (0, logger_1.c)('green', result.minimality_score + '/100') : (0, logger_1.c)('red', result.minimality_score + '/100')}`);
+        (0, logger_1.log)(`  Decision Classification:   ${(0, logger_1.c)('cyan', result.minimality_classification)}`);
+        (0, logger_1.log)(`  Strictness Mode:           ${(0, logger_1.c)('yellow', mode)}`);
+        console.log();
+
+        if (result.change_budget) {
+            (0, logger_1.log)(`  ${(0, logger_1.bold)('Change Budget:')}`);
+            (0, logger_1.log)(`    files_added:           ${result.change_budget.files_added}`);
+            (0, logger_1.log)(`    files_modified:        ${result.change_budget.files_modified}`);
+            (0, logger_1.log)(`    dependencies_added:    ${result.change_budget.dependencies_added}`);
+            (0, logger_1.log)(`    new_abstractions:      ${result.change_budget.new_abstractions}`);
+            console.log();
+        }
+
+        if (result.complexity_flags.length > 0) {
+            (0, logger_1.log)(`  ${(0, logger_1.c)('yellow', 'Complexity Flags Detected:')}`);
+            result.complexity_flags.forEach(f => {
+                (0, logger_1.log)(`    • [${f.severity.toUpperCase()}] ${f.type}: ${f.evidence}`);
+            });
+            console.log();
+        } else {
+            (0, logger_1.log)(`  ${(0, logger_1.c)('green', '✔ Zero Complexity Flags Detected')}`);
+            console.log();
+        }
+    } catch (err) {
+        (0, logger_1.log)(`  ${(0, logger_1.c)('red', '✖ Error executing Minimal Change Engine:')} ${err.message}`);
+    }
+}

package/dist/commands/native.js

@@ -219,10 +219,46 @@ function cmdOptimizeStep(processArgs, quiet = false) {
   console.log(JSON.stringify(result));
   return true;
 }
+function cmdImpactTier(processArgs, quiet = false) {
+  const args = processArgs.slice(3);
+  const files = getOption(args, ["--files"]) || "";
+  const lines = parseInt(getOption(args, ["--lines"]) || "0", 10);
+  const task = getOption(args, ["--task"]) || "";
+
+  const fileList = files ? files.split(",").map(f => f.trim()).filter(Boolean) : [];
+  const fileCount = fileList.length;
+
+  // Tier classification heuristics (mirrors Rust ImpactTier logic)
+  let tier = 0;
+  if (fileCount === 0 && lines <= 5) tier = 0;
+  else if (fileCount <= 1 && lines <= 50) tier = 1;
+  else if (fileCount <= 5 && lines <= 200) tier = 2;
+  else tier = 3;
+
+  // Check for high-risk patterns that force Tier 3
+  const highRiskPatterns = /\b(auth|migration|schema|security|password|token|jwt|rbac|permissions)\b/i;
+  const highRiskExtensions = /\.(sql|prisma|tf|tofu)$/i;
+  if (highRiskPatterns.test(task) || fileList.some(f => highRiskExtensions.test(f))) {
+    tier = Math.max(tier, 3);
+  }
+
+  const tierNames = ["Fast-Pass", "Express Pass", "Targeted Audit", "Full Gauntlet"];
+  const result = {
+    tier,
+    tier_name: tierNames[tier],
+    file_count: fileCount,
+    line_count: lines,
+    socratic_gate: tier >= 3 ? "required" : tier >= 2 ? "conditional" : "bypass",
+  };
+  if (!quiet) console.error(`✓ Impact Tier: ${tier} (${tierNames[tier]})`);
+  console.log(JSON.stringify(result));
+  return true;
+}
 
 module.exports = {
   cmdMinContext,
   cmdDagSchedule,
   cmdContextCompress,
   cmdOptimizeStep,
+  cmdImpactTier,
 };

package/dist/commands/optimize.js

@@ -9,7 +9,7 @@ const fs = __importDefault(require("fs"));
 const path = __importDefault(require("path"));
 const os = __importDefault(require("os"));
 const https = __importDefault(require("https"));
-const { execSync } = require("child_process");
+const { execSync, spawnSync } = require("child_process");
 const logger = require("../utils/logger");
 const helpers = require("../utils/helpers");
 
@@ -253,10 +253,20 @@ Each edit must follow this schema:
             const tempFile = path.default.join(os.default.tmpdir(), `edits-${Date.now()}.json`);
             fs.default.writeFileSync(tempFile, cleanedJson, 'utf8');
             
-            optResultStr = execSync(
-                `"${binPath}" optimize-step --skill-path "${skillPath}" --edits-json "${cleanedJson.replace(/"/g, '\\"')}" --budget ${editBudget}`,
-                { encoding: 'utf8', cwd: targetDir, stdio: 'pipe' }
-            );
+            const result = spawnSync(binPath, [
+                "optimize-step",
+                "--skill-path",
+                skillPath,
+                "--edits-json",
+                cleanedJson,
+                "--budget",
+                String(editBudget)
+            ], { encoding: 'utf8', cwd: targetDir, stdio: 'pipe' });
+            
+            if (result.error) {
+                throw result.error;
+            }
+            optResultStr = result.stdout || "";
             
             try { fs.default.unlinkSync(tempFile); } catch {}
         } catch (e) {

package/dist/esm/index.mjs

@@ -34,83 +34,109 @@ export const runShellAsync = helpers.runShellAsync;
 export const getKitAgent = helpers.getKitAgent;
 export const banner = helpers.banner;
 
+// Helper to wrap CommonJS requires in friendly error diagnostics
+function loadCommand(modulePath, functionName, ...args) {
+  try {
+    const mod = require(modulePath);
+    return mod[functionName](...args);
+  } catch (err) {
+    throw new Error(`Tribunal ESM wrapper failed to load command '${functionName}' from '${modulePath}': ${err.message}`);
+  }
+}
+
 // ── Lazy command loaders (imported on demand) ────────────
 export async function cmdInit(flags, quiet) {
-  const mod = require('../commands/init.js');
-  return mod.cmdInit(flags, quiet);
+  return loadCommand('../commands/init.js', 'cmdInit', flags, quiet);
 }
 
 export async function cmdUpdate(flags) {
-  const mod = require('../commands/update.js');
-  return mod.cmdUpdate(flags);
+  return loadCommand('../commands/update.js', 'cmdUpdate', flags);
 }
 
 export function cmdStatus(flags, quiet) {
-  const mod = require('../commands/status.js');
-  return mod.cmdStatus(flags, quiet);
+  return loadCommand('../commands/status.js', 'cmdStatus', flags, quiet);
 }
 
 export async function cmdLearn(flags, quiet) {
-  const mod = require('../commands/learn.js');
-  return mod.cmdLearn(flags, quiet);
+  return loadCommand('../commands/learn.js', 'cmdLearn', flags, quiet);
 }
 
 export async function cmdCase(flags, argv, quiet) {
-  const mod = require('../commands/case.js');
-  return mod.cmdCase(flags, argv, quiet);
+  return loadCommand('../commands/case.js', 'cmdCase', flags, argv, quiet);
 }
 
 export function cmdHook(flags) {
-  const mod = require('../commands/hook.js');
-  return mod.cmdHook(flags);
+  return loadCommand('../commands/hook.js', 'cmdHook', flags);
 }
 
 export async function cmdGraph(flags, quiet) {
-  const mod = require('../commands/graph.js');
-  return mod.cmdGraph(flags, quiet);
+  return loadCommand('../commands/graph.js', 'cmdGraph', flags, quiet);
 }
 
 export async function cmdMutate(flags, argv) {
-  const mod = require('../commands/mutate.js');
-  return mod.cmdMutate(flags, argv);
+  return loadCommand('../commands/mutate.js', 'cmdMutate', flags, argv);
 }
 
 export function cmdContext(flags, argv) {
-  const mod = require('../commands/context.js');
-  return mod.cmdContext(flags, argv);
+  return loadCommand('../commands/context.js', 'cmdContext', flags, argv);
 }
 
 export async function cmdSync() {
-  const mod = require('../commands/sync.js');
-  return mod.cmdSync();
+  return loadCommand('../commands/sync.js', 'cmdSync');
 }
 
 export async function cmdAlign(flags, argv, quiet) {
-  const mod = require('../commands/align.js');
-  return mod.cmdAlign(flags, argv, quiet);
+  return loadCommand('../commands/align.js', 'cmdAlign', flags, argv, quiet);
 }
 
 export async function cmdMarathon(flags, argv, quiet) {
-  const mod = require('../commands/marathon.js');
-  return mod.cmdMarathon(flags, argv, quiet);
+  return loadCommand('../commands/marathon.js', 'cmdMarathon', flags, argv, quiet);
 }
 
 export async function cmdCompile(flags, quiet) {
-  const mod = require('../commands/compile.js');
-  return mod.cmdCompile(flags, quiet);
+  return loadCommand('../commands/compile.js', 'cmdCompile', flags, quiet);
 }
 
 export async function cmdMemory(flags, argv, quiet) {
-  const mod = require('../commands/memory.js');
-  return mod.cmdMemory(flags, argv, quiet);
+  return loadCommand('../commands/memory.js', 'cmdMemory', flags, argv, quiet);
 }
 
 export function cmdUninstall(flags, quiet) {
-  const mod = require('../commands/uninstall.js');
-  return mod.cmdUninstall(flags, quiet);
+  return loadCommand('../commands/uninstall.js', 'cmdUninstall', flags, quiet);
 }
 
 export async function generateIDEBridges(cwd, agentDest, quiet) {
-  const mod = require('../commands/init.js');
-  return mod.generateIDEBridges(cwd, agentDest, quiet);
+  return loadCommand('../commands/init.js', 'generateIDEBridges', cwd, agentDest, quiet);
+}
+
+export async function cmdGuardrail(flags, argv, quiet) {
+  return loadCommand('../commands/guardrail.js', 'cmdGuardrail', flags, argv, quiet);
+}
+
+export async function cmdOptimizeSkill(flags, argv, quiet) {
+  return loadCommand('../commands/optimize.js', 'cmdOptimizeSkill', flags, argv, quiet);
+}
+
+export function cmdMinimal(flags, quiet) {
+  return loadCommand('../commands/minimal.js', 'cmdMinimal', flags, quiet);
+}
+
+export function cmdValidate(flags, argv, quiet) {
+  return loadCommand('../commands/validate.js', 'cmdValidate', flags, argv, quiet);
+}
+
+export function cmdMinContext(argv, quiet) {
+  return loadCommand('../commands/native.js', 'cmdMinContext', argv, quiet);
+}
+
+export function cmdDagSchedule(argv, quiet) {
+  return loadCommand('../commands/native.js', 'cmdDagSchedule', argv, quiet);
+}
+
+export function cmdContextCompress(argv, quiet) {
+  return loadCommand('../commands/native.js', 'cmdContextCompress', argv, quiet);
+}
+
+export function cmdOptimizeStep(argv, quiet) {
+  return loadCommand('../commands/native.js', 'cmdOptimizeStep', argv, quiet);
 }

package/dist/index.d.ts

@@ -37,8 +37,8 @@ export interface CliFlags {
   log?: string;
   /** Memory mutation strategy: 'balanced' | 'harden' | 'repair-only'. */
   strategy?: string;
-  /** Enable token-optimized output. */
-  tokenOptimized?: boolean;
+  /** Install profile: 'full' | 'minimal' | 'web' | 'mobile' | 'backend' | 'ai'. */
+  profile?: string;
 }
 
 /** Parsed CLI arguments returned by the internal arg parser. */
@@ -145,6 +145,54 @@ export function cmdUninstall(flags: CliFlags, quiet?: boolean): void;
  */
 export function generateIDEBridges(cwd: string, agentDest: string, quiet?: boolean): Promise<void>;
 
+/**
+ * Validate `.agent/` integrity (phantom refs, count mismatches, drift).
+ * Equivalent to `npx tribunal-kit guardrail`.
+ */
+export function cmdGuardrail(flags: CliFlags, argv: string[], quiet?: boolean): Promise<void>;
+
+/**
+ * Optimize project skills using SkillOpt validation gates.
+ * Equivalent to `npx tribunal-kit optimize-skill`.
+ */
+export function cmdOptimizeSkill(flags: CliFlags, argv: string[], quiet?: boolean): Promise<void>;
+
+/**
+ * Show minimal change analysis for the current project.
+ * Equivalent to `npx tribunal-kit minimal`.
+ */
+export function cmdMinimal(flags: CliFlags, quiet?: boolean): void;
+
+/**
+ * Validate a JSON payload against a Tribunal schema.
+ * Equivalent to `npx tribunal-kit validate`.
+ */
+export function cmdValidate(flags: CliFlags, argv: string[], quiet?: boolean): void;
+
+/**
+ * Remove empty lines from a context file.
+ * Equivalent to `npx tribunal-kit min-context`.
+ */
+export function cmdMinContext(argv: string[], quiet?: boolean): void;
+
+/**
+ * Compute parallel execution waves from task dependencies.
+ * Equivalent to `npx tribunal-kit dag-schedule`.
+ */
+export function cmdDagSchedule(argv: string[], quiet?: boolean): void;
+
+/**
+ * Compress a context file while retaining VERIFY comments.
+ * Equivalent to `npx tribunal-kit context-compress`.
+ */
+export function cmdContextCompress(argv: string[], quiet?: boolean): void;
+
+/**
+ * Apply bounded SkillOpt edits from a JSON payload.
+ * Equivalent to `npx tribunal-kit optimize-step`.
+ */
+export function cmdOptimizeStep(argv: string[], quiet?: boolean): void;
+
 // ── Logger Utilities ─────────────────────────────────────────────────────────
 
 /** ANSI color code map. */

package/dist/utils/fs.js

@@ -12,7 +12,10 @@ const logger_1 = require("./logger");
 // Concurrency limit for parallel file operations to avoid fd exhaustion
 const COPY_CONCURRENCY = 32;
 
-async function copyDir(src, dest, dryRun = false, filter = null) {
+async function copyDir(src, dest, dryRun = false, filter = null, currentDepth = 0) {
+    if (currentDepth > 20) {
+        throw new Error(`Maximum directory copy depth (20) exceeded at: ${src}`);
+    }
     if (!dryRun) {
         await fs_1.default.promises.mkdir(dest, { recursive: true });
     }
@@ -51,7 +54,7 @@ async function copyDir(src, dest, dryRun = false, filter = null) {
 
     // Recurse into directories in parallel (dirs are I/O-independent)
     const dirResults = await Promise.all(
-        dirs.map(({ srcPath, destPath }) => copyDir(srcPath, destPath, dryRun, filter))
+        dirs.map(({ srcPath, destPath }) => copyDir(srcPath, destPath, dryRun, filter, currentDepth + 1))
     );
     for (const dirCount of dirResults) {
         count += dirCount;
@@ -59,12 +62,15 @@ async function copyDir(src, dest, dryRun = false, filter = null) {
 
     return count;
 }
-async function countDir(dir) {
+async function countDir(dir, currentDepth = 0) {
+    if (currentDepth > 20) {
+        throw new Error(`Maximum directory count depth (20) exceeded at: ${dir}`);
+    }
     let count = 0;
     const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
         if (e.isDirectory())
-            count += await countDir(path_1.default.join(dir, e.name));
+            count += await countDir(path_1.default.join(dir, e.name), currentDepth + 1);
         else
             count++;
     }

package/dist/utils/helpers.js

@@ -12,14 +12,23 @@ const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
 function runShellAsync(command, options) {
     return new Promise((resolve, reject) => {
+        const timeoutMs = (options && options.timeout) || 120000;
         const child = (0, child_process_1.spawn)(command, [], { ...options, shell: true });
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
+        }, timeoutMs);
         child.on('close', code => {
+            clearTimeout(timer);
             if (code !== 0)
                 reject(new Error(`Command failed with exit code ${code}`));
             else
                 resolve();
         });
-        child.on('error', reject);
+        child.on('error', err => {
+            clearTimeout(timer);
+            reject(err);
+        });
     });
 }
 function getKitAgent() {