agentic-workflow-manager 9.5.0 → 9.6.1

package/dist/tests/commands/sensors/exec.test.js

@@ -8,6 +8,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const exec_1 = require("../../../src/commands/sensors/exec");
 const result_1 = require("../../../src/commands/sensors/result");
+const baseline_1 = require("../../../src/commands/sensors/baseline");
 const prepare_1 = require("../../../src/commands/sensors/prepare");
 const sensor = (overrides = {}) => ({
     name: 'lint',
@@ -21,6 +22,7 @@ const sensor = (overrides = {}) => ({
 });
 const onPosix = process.platform !== 'win32' ? describe : describe.skip;
 const itPosix = process.platform !== 'win32' ? it : it.skip;
+const itLinux = process.platform === 'linux' ? it : it.skip;
 /** Poll until `fn()` is true or the budget runs out. Avoids fixed sleeps. */
 async function until(fn, budgetMs = 4000) {
     const deadline = Date.now() + budgetMs;
@@ -57,6 +59,78 @@ describe('runCommand — exit codes and output', () => {
             fs_1.default.rmSync(dir, { recursive: true, force: true });
         }
     });
+    it('preserves a structured non-zero report for interpretation and baseline suppression', async () => {
+        const command = {
+            executable: 'node',
+            resolution: 'path',
+            args: ['-e', "console.log('structured finding'); process.exit(1)"],
+        };
+        const raw = await (0, exec_1.runStructuredCommand)(command, { timeout: 5_000, cwd: process.cwd() });
+        expect(raw).toMatchObject({ code: 1, stdout: 'structured finding\n', timedOut: false, overflowed: false });
+        const interpreted = (0, result_1.interpretResult)(sensor({ command: { kind: 'structured', value: command } }), raw);
+        expect(interpreted).toMatchObject({ status: 'fail', errors: [{ message: expect.stringContaining('structured finding') }] });
+        const suppressed = (0, result_1.applyBaseline)(interpreted, [(0, baseline_1.fingerprint)('lint', interpreted.errors[0])]);
+        expect(suppressed).toMatchObject({ status: 'pass', errors: [], baselineCount: 1 });
+    });
+    it('keeps an unrelated structured non-zero exit non-passing', async () => {
+        const raw = await (0, exec_1.runStructuredCommand)({
+            executable: 'node',
+            resolution: 'path',
+            args: ['-e', 'process.exit(3)'],
+        }, { timeout: 5_000, cwd: process.cwd() });
+        const interpreted = (0, result_1.interpretResult)(sensor({ command: { kind: 'structured', value: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(3)'] } } }), raw);
+        expect(interpreted.status).not.toBe('pass');
+    });
+    itLinux('keeps structured stderr separate from exit-0 stdout findings', async () => {
+        const command = {
+            executable: 'perl',
+            resolution: 'path',
+            args: ['-e', 'print STDERR "warning only\\n"'],
+        };
+        const raw = await (0, exec_1.runStructuredCommand)(command, { timeout: 5_000, cwd: process.cwd() });
+        expect(raw).toMatchObject({ code: 0, stdout: '', stderr: 'warning only\n' });
+        expect((0, result_1.interpretResult)(sensor({ command: { kind: 'structured', value: command } }), raw)).toMatchObject({ status: 'pass', errors: [] });
+    });
+    itLinux('never lets a structured capture file grow beyond maxBuffer', async () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-exec-cap-'));
+        const marker = path_1.default.join(dir, 'written');
+        const existing = new Set(fs_1.default.readdirSync(os_1.default.tmpdir()).filter(name => name.startsWith('awm-sensor-output-')));
+        try {
+            const result = (0, exec_1.runStructuredCommand)({
+                executable: 'node',
+                resolution: 'path',
+                args: ['-e', `const fs = require('fs'); try { fs.writeSync(1, Buffer.alloc(8192, 'x')); } catch {} fs.writeFileSync(${JSON.stringify(marker)}, 'written'); setTimeout(() => {}, 1000);`],
+            }, { timeout: 5_000, cwd: dir, maxBuffer: 1_024 });
+            expect(await until(() => fs_1.default.existsSync(marker))).toBe(true);
+            const capture = fs_1.default.readdirSync(os_1.default.tmpdir()).find(name => name.startsWith('awm-sensor-output-') && !existing.has(name));
+            expect(capture).toBeDefined();
+            expect(fs_1.default.statSync(path_1.default.join(os_1.default.tmpdir(), capture, 'stdout')).size).toBeLessThanOrEqual(1_024);
+            await expect(result).resolves.toMatchObject({ overflowed: true });
+        }
+        finally {
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    itLinux('bounds combined structured stdout and stderr by maxBuffer', async () => {
+        const result = await (0, exec_1.runStructuredCommand)({
+            executable: 'node',
+            resolution: 'path',
+            args: ['-e', "process.stdout.write('o'.repeat(700)); process.stderr.write('e'.repeat(700)); setTimeout(() => {}, 1000);"],
+        }, { timeout: 5_000, cwd: process.cwd(), maxBuffer: 1_024 });
+        expect(result.overflowed).toBe(true);
+        expect(Buffer.byteLength(result.stdout) + Buffer.byteLength(result.stderr)).toBeLessThanOrEqual(1_024);
+        expect(result.stdout).toMatch(/^o+$/);
+        expect(result.stderr).toMatch(/^e+$/);
+    });
+    itLinux('allows one structured stream to use the full global budget', async () => {
+        const result = await (0, exec_1.runStructuredCommand)({
+            executable: 'perl',
+            resolution: 'path',
+            args: ['-e', "print 'o' x 700"],
+        }, { timeout: 5_000, cwd: process.cwd(), maxBuffer: 1_024 });
+        expect(result).toMatchObject({ code: 0, overflowed: false, stderr: '' });
+        expect(Buffer.byteLength(result.stdout)).toBe(700);
+    });
     it('returns stdout and code 0 for a clean command', async () => {
         const r = await (0, exec_1.runCommand)('echo hello', { timeout: 5000, cwd: process.cwd() });
         expect(r.code).toBe(0);
@@ -107,6 +181,18 @@ onPosix('runCommand — output cap', () => {
         // The point of the cap change: what was read is still usable, not discarded.
         expect(r.stdout).toMatch(/line-padding/);
     });
+    it('counts multibyte UTF-8 output against maxBuffer in bytes', async () => {
+        const r = await (0, exec_1.runCommand)("yes '€'", { timeout: 5_000, cwd: process.cwd(), maxBuffer: 1_024 });
+        expect(r.overflowed).toBe(true);
+        expect(Buffer.byteLength(r.stdout) + Buffer.byteLength(r.stderr)).toBeLessThanOrEqual(1_024);
+    });
+    it.each([
+        ["perl -e 'print chr(255) x 1024'", 'invalid bytes'],
+        ["perl -e 'print \"\\xE2\\x82\" x 512'", 'truncated UTF-8 sequences'],
+    ])('never expands %s beyond maxBuffer while decoding %s', async (command) => {
+        const r = await (0, exec_1.runCommand)(command, { timeout: 5_000, cwd: process.cwd(), maxBuffer: 1_024 });
+        expect(Buffer.byteLength(r.stdout) + Buffer.byteLength(r.stderr)).toBeLessThanOrEqual(1_024);
+    });
 });
 onPosix('runCommand — timeout', () => {
     it('flags the timeout and returns the output produced before the deadline', async () => {

package/dist/tests/commands/sensors/index.test.js

@@ -10,12 +10,14 @@ jest.mock('../../../src/commands/sensors/baseline', () => ({ buildBaseline: jest
 jest.mock('../../../src/core/registries', () => ({ capabilityRoot: jest.fn(() => '/mock/registry') }));
 jest.mock('../../../src/commands/sensors/coverage', () => ({ runCoverage: jest.fn() }));
 jest.mock('../../../src/commands/sensors/coverage/render', () => ({ renderCoverageHuman: jest.fn(), renderCoverageJson: jest.fn() }));
+jest.mock('../../../src/commands/sensors/bootstrap', () => ({ planSensorBootstrap: jest.fn(), applySensorBootstrap: jest.fn() }));
 const commander_1 = require("commander");
 const prompts_1 = require("@clack/prompts");
 const coverage_1 = require("../../../src/commands/sensors/coverage");
 const render_1 = require("../../../src/commands/sensors/coverage/render");
 const index_1 = require("../../../src/commands/sensors/index");
 const verdict_1 = require("../../../src/commands/sensors/verdict");
+const bootstrap_1 = require("../../../src/commands/sensors/bootstrap");
 const processExit = jest.spyOn(process, 'exit').mockImplementation((() => undefined));
 const stdoutWrite = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
 describe('exitCodeForVerdict — sensor run verdict → exit code', () => {
@@ -28,6 +30,58 @@ describe('exitCodeForVerdict — sensor run verdict → exit code', () => {
         expect((0, verdict_1.exitCodeForVerdict)(overall)).toBe(code);
     });
 });
+describe('sensors bootstrap Commander wiring', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.exitCode = undefined;
+    });
+    it('renders dry-run without calling the applier', async () => {
+        bootstrap_1.planSensorBootstrap.mockResolvedValue({
+            kind: 'create', dryRun: true, changes: [{ path: '.awm/sensors.json', action: 'create' }],
+            manifest: { schemaVersion: 3, mode: 'native-gate', reason: 'CI' },
+        });
+        const program = new commander_1.Command();
+        program.exitOverride();
+        (0, index_1.registerSensorsCommand)(program);
+        await program.parseAsync(['node', 'awm', 'sensors', 'bootstrap', '--mode', 'native-gate', '--reason', 'CI', '--dry-run']);
+        expect(bootstrap_1.planSensorBootstrap).toHaveBeenCalledWith(process.cwd(), { mode: 'native-gate', reason: 'CI', dryRun: true });
+        expect(bootstrap_1.applySensorBootstrap).not.toHaveBeenCalled();
+        expect(prompts_1.log.info).toHaveBeenCalledWith(expect.stringContaining('dry-run'));
+    });
+    it('renders the chosen project-sensors pack in dry-run output', async () => {
+        bootstrap_1.planSensorBootstrap.mockResolvedValue({
+            kind: 'create', dryRun: true, changes: [{ path: '.awm/sensors.json', action: 'create' }],
+            manifest: { schemaVersion: 3, mode: 'project-sensors', pack: 'js-ts' },
+        });
+        const program = new commander_1.Command();
+        program.exitOverride();
+        (0, index_1.registerSensorsCommand)(program);
+        await program.parseAsync(['node', 'awm', 'sensors', 'bootstrap', '--mode', 'project-sensors', '--dry-run']);
+        expect(prompts_1.log.info).toHaveBeenCalledWith(expect.stringContaining('pack=js-ts'));
+        expect(bootstrap_1.applySensorBootstrap).not.toHaveBeenCalled();
+    });
+    it('applies an executable plan and reports its result', async () => {
+        const plan = { kind: 'create', dryRun: false, changes: [{ path: '.awm/sensors.json', action: 'create' }], manifest: { schemaVersion: 3, mode: 'native-gate', reason: 'CI' } };
+        bootstrap_1.planSensorBootstrap.mockResolvedValue(plan);
+        bootstrap_1.applySensorBootstrap.mockReturnValue('created');
+        const program = new commander_1.Command();
+        program.exitOverride();
+        (0, index_1.registerSensorsCommand)(program);
+        await program.parseAsync(['node', 'awm', 'sensors', 'bootstrap', '--mode', 'native-gate', '--reason', 'CI']);
+        expect(bootstrap_1.applySensorBootstrap).toHaveBeenCalledWith(plan);
+        expect(prompts_1.log.success).toHaveBeenCalledWith(expect.stringContaining('created'));
+    });
+    it('returns a non-zero semantic exit for a blocked plan', async () => {
+        bootstrap_1.planSensorBootstrap.mockResolvedValue({ kind: 'blocked', dryRun: false, reason: 'mode-required', remedy: 'choose-mode' });
+        const program = new commander_1.Command();
+        program.exitOverride();
+        (0, index_1.registerSensorsCommand)(program);
+        await program.parseAsync(['node', 'awm', 'sensors', 'bootstrap']);
+        expect(process.exitCode).toBe(1);
+        expect(prompts_1.log.error).toHaveBeenCalledWith('mode-required: choose-mode');
+        expect(bootstrap_1.applySensorBootstrap).not.toHaveBeenCalled();
+    });
+});
 describe('sensors run Commander wiring', () => {
     const originalExitCode = process.exitCode;
     beforeEach(() => {

package/dist/tests/commands/sensors/init-pack-unavailable.test.js

@@ -3,94 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// `awm sensors init` auto-detects the stack, then reads that pack's defaults out of
-// the registry. When the registry has no such pack — a pinned or stale registry, or one
-// that simply never shipped it — `readPackDefaults` returned null and the manifest was
-// written EMPTY, with no error and no warning:
-//
-//     $ awm sensors init          # python project, registry predates the python pack
-//     ✔ Detected: python (pyproject.toml)
-//     ✔ Wrote .awm/sensors.json          ← {"pack":"python","sensors":{}}
-//
-// Nothing in that output says the quality gate now checks nothing. The operator finds
-// out later, from an unrelated command (`awm preflight` exits 1, `awm sensors status`
-// reports DEGRADED), and the manifest is by then committed.
-//
-// `--pack <name>` has always validated against the registry and thrown (assertPackExists).
-// Auto-detection reaching the same dead end must not be quieter than the explicit path:
-// it now falls back to a pack the registry actually has, and says which pack was missing
-// so the operator hears it at the moment the decision is made.
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+jest.mock('../../../src/commands/sensors/bootstrap', () => ({
+    planSensorBootstrap: jest.fn(),
+    applySensorBootstrap: jest.fn(),
+}));
 const init_1 = require("../../../src/commands/sensors/init");
-function mkRegistry(packs) {
-    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-packreg-'));
-    for (const [name, sensors] of Object.entries(packs)) {
-        const dir = path_1.default.join(root, 'sensor-packs', name);
-        fs_1.default.mkdirSync(dir, { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(dir, 'pack.json'), JSON.stringify({ name, sensors }));
-    }
-    return root;
-}
-function mkPythonProject() {
-    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-packproj-'));
-    fs_1.default.writeFileSync(path_1.default.join(dir, 'pyproject.toml'), '[project]\nname = "x"\n');
-    return dir;
-}
-const GENERIC = { security: { defaultCmd: 'semgrep .', fast: false } };
-const PYTHON = { typecheck: { defaultCmd: 'mypy .', fast: true, formatter: 'mypy' } };
-describe('awm sensors init — detected pack missing from the registry', () => {
-    const made = [];
-    const registry = (packs) => { const r = mkRegistry(packs); made.push(r); return r; };
-    const project = () => { const p = mkPythonProject(); made.push(p); return p; };
-    const manifestOf = (dir) => JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
-    afterAll(() => { for (const d of made)
-        fs_1.default.rmSync(d, { recursive: true, force: true }); });
-    it('names the missing pack instead of writing an empty manifest silently', async () => {
-        const cwd = project();
-        const result = await (0, init_1.initSensors)({ cwd, registryRoot: registry({ 'js-ts': {}, generic: GENERIC }) });
-        expect(result.unavailablePack).toBe('python');
-        expect(result.detection.pack).toBe('python'); // what the tree actually is — unchanged
+const bootstrap_1 = require("../../../src/commands/sensors/bootstrap");
+describe('initSensors when a pack is unavailable', () => {
+    let project;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-unavailable-'));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'pyproject.toml'), '[project]\nname = "fixture"\n');
     });
-    it('falls back to a pack the registry does have, so the gate still measures something', async () => {
-        const cwd = project();
-        const result = await (0, init_1.initSensors)({ cwd, registryRoot: registry({ 'js-ts': {}, generic: GENERIC }) });
-        expect(result.manifest.pack).toBe('generic');
-        expect(Object.keys(result.manifest.sensors)).toEqual(['security']);
-        expect(manifestOf(cwd).pack).toBe('generic');
-    });
-    it('stays on the detected pack when the registry has no fallback either', async () => {
-        // Nothing better exists. The manifest is honestly empty and still says so —
-        // preflight's `manifest` check fails on `total === 0` with a registry remedy.
-        const cwd = project();
-        const result = await (0, init_1.initSensors)({ cwd, registryRoot: registry({ 'js-ts': {} }) });
-        expect(result.unavailablePack).toBe('python');
-        expect(result.manifest.pack).toBe('python');
-        expect(result.manifest.sensors).toEqual({});
-    });
-    it('is quiet when the registry does have the detected pack', async () => {
-        const cwd = project();
-        const result = await (0, init_1.initSensors)({ cwd, registryRoot: registry({ python: PYTHON, generic: GENERIC }) });
-        expect(result.unavailablePack).toBeUndefined();
-        expect(result.manifest.pack).toBe('python');
-        expect(Object.keys(result.manifest.sensors)).toEqual(['typecheck']);
-    });
-    it('does not fall back when there is no registry to check against', async () => {
-        // No registryRoot means nothing to validate against, the same tolerance
-        // `--pack` already has — not evidence that the pack is missing.
-        const cwd = project();
-        const result = await (0, init_1.initSensors)({ cwd });
-        expect(result.unavailablePack).toBeUndefined();
-        expect(result.manifest.pack).toBe('python');
-    });
-    it('keeps sensors the user already had when falling back', async () => {
-        // The fallback must not be a way to lose hand-written configuration.
-        const cwd = project();
-        fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
-        fs_1.default.writeFileSync(path_1.default.join(cwd, '.awm', 'sensors.json'), JSON.stringify({ pack: 'python', sensors: { test: { cmd: 'pytest -q', fast: false } } }));
-        const result = await (0, init_1.initSensors)({ cwd, registryRoot: registry({ generic: GENERIC }) });
-        expect(result.manifest.sensors.test?.cmd).toBe('pytest -q');
-        expect(Object.keys(result.manifest.sensors).sort()).toEqual(['security', 'test']);
+    afterEach(() => fs_1.default.rmSync(project, { recursive: true, force: true }));
+    it('fails closed with the portable bootstrap remedy rather than writing an empty or fallback v2 manifest', async () => {
+        bootstrap_1.planSensorBootstrap.mockResolvedValue({
+            kind: 'blocked', projectRoot: project, manifestPath: path_1.default.join(project, '.awm', 'sensors.json'), changes: [], dryRun: false,
+            reason: 'source-unavailable', remedy: 'install-registry-or-run-awm-update',
+        });
+        await expect((0, init_1.initSensors)({ cwd: project, registryRoot: '/stale/registry' }))
+            .rejects.toThrow('source-unavailable: install-registry-or-run-awm-update');
+        expect(bootstrap_1.applySensorBootstrap).not.toHaveBeenCalled();
+        expect(fs_1.default.existsSync(path_1.default.join(project, '.awm', 'sensors.json'))).toBe(false);
     });
 });