agentic-workflow-manager 9.16.1 → 9.18.0

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

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const env_1 = require("../../../src/commands/env");
+const store_1 = require("../../../src/core/environments/store");
+const catalog = {
+    schemaVersion: 1,
+    facts: {
+        'repos.root': {
+            valueType: 'path',
+            resolution: 'prompt',
+            durability: 'durable',
+            inject: 'reference',
+        },
+        'aws.profile': {
+            valueType: 'string',
+            resolution: 'prompt',
+            durability: 'durable',
+            inject: 'reference',
+        },
+        'env.kind': {
+            valueType: 'enum',
+            resolution: 'prompt',
+            durability: 'durable',
+            inject: 'reference',
+            values: ['dev', 'prod'],
+        },
+        'aws.token': {
+            valueType: 'string',
+            resolution: 'prompt',
+            durability: 'volatile',
+            inject: 'reference',
+            ttl: 1,
+        },
+    },
+};
+function isolateHome() {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-env-cmd-'));
+    process.env.AWM_HOME = path_1.default.join(tmp, '.awm');
+    process.env.HOME = tmp;
+    return tmp;
+}
+async function run(argv, loadCatalog = () => catalog, extraDeps = {}) {
+    const prog = new commander_1.Command();
+    prog.exitOverride();
+    prog.configureOutput({ writeErr: () => undefined });
+    (0, env_1.registerEnvCommand)(prog, {
+        loadCatalog,
+        consultedRoots: () => ['/tmp/test-registry'],
+        stdinIsTTY: () => false,
+        ...extraDeps,
+    });
+    const outSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const errSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    try {
+        await prog.parseAsync(['node', 'awm', 'env', ...argv]);
+    }
+    finally {
+        // keep spies until we collect
+    }
+    const out = outSpy.mock.calls.map((c) => String(c[0])).join('') +
+        logSpy.mock.calls.map((c) => c.map(String).join(' ')).join('\n');
+    const err = errSpy.mock.calls.map((c) => String(c[0])).join('') +
+        errorSpy.mock.calls.map((c) => c.map(String).join(' ')).join('\n');
+    outSpy.mockRestore();
+    errSpy.mockRestore();
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    return { out, err };
+}
+describe('awm env commands (RF-2, RF-3.3)', () => {
+    let tmp;
+    let prevHome;
+    let prevAwm;
+    beforeEach(() => {
+        prevHome = process.env.HOME;
+        prevAwm = process.env.AWM_HOME;
+        tmp = isolateHome();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+        if (prevHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = prevHome;
+        if (prevAwm === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = prevAwm;
+    });
+    it('set --value writes under environments/default/values.json without shelling out (RF-2.1, RF-3.3)', async () => {
+        const spawn = jest.spyOn(require('child_process'), 'spawnSync');
+        const execFile = jest.spyOn(require('child_process'), 'execFileSync');
+        await run(['set', 'repos.root', '--value', '/machine/repos']);
+        expect((0, store_1.readValues)('default')['repos.root'].value).toBe('/machine/repos');
+        expect(fs_1.default.existsSync((0, store_1.valuesPath)('default'))).toBe(true);
+        expect((0, store_1.valuesPath)('default')).toContain(path_1.default.join('.awm', 'environments', 'default', 'values.json'));
+        expect(spawn).not.toHaveBeenCalled();
+        expect(execFile).not.toHaveBeenCalled();
+        spawn.mockRestore();
+        execFile.mockRestore();
+    });
+    it('status reports missing for unset facts and fresh after set (RF-2.5)', async () => {
+        let { out } = await run(['status']);
+        expect(out).toMatch(/repos\.root:\s*missing/);
+        expect(out).toMatch(/aws\.profile:\s*missing/);
+        await run(['set', 'repos.root', '--value', '/r']);
+        ({ out } = await run(['status']));
+        expect(out).toMatch(/repos\.root:\s*fresh/);
+        // Unset sibling stays missing — no silent default invent for other ids.
+        expect(out).toMatch(/aws\.profile:\s*missing/);
+        expect(out).not.toMatch(/aws\.profile:\s*fresh/);
+    });
+    it('status reports stale for expired volatile fact (RF-2.5)', async () => {
+        (0, store_1.writeFact)('default', 'aws.token', {
+            value: 'tok',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        }, { definition: catalog.facts['aws.token'] });
+        const { out } = await run(['status'], () => catalog, {
+            now: () => new Date('2026-10-12T00:00:02.000Z'),
+        });
+        expect(out).toMatch(/aws\.token:\s*stale/);
+    });
+    it('edit prints absolute store path', async () => {
+        const { out } = await run(['edit']);
+        expect(out).toContain((0, store_1.valuesPath)((0, store_1.getActiveEnvironmentName)()));
+        expect(path_1.default.isAbsolute(out.trim().split(/\s+/).find((t) => t.includes('values.json')) || (0, store_1.valuesPath)('default'))).toBe(true);
+    });
+    it('refresh --value updates an existing fact without shell (RF-3.3)', async () => {
+        await run(['set', 'aws.profile', '--value', 'old']);
+        await run(['refresh', 'aws.profile', '--value', 'new-profile']);
+        expect((0, store_1.readValues)('default')['aws.profile'].value).toBe('new-profile');
+    });
+    it('refresh without --value in non-interactive mode errors', async () => {
+        await run(['set', 'aws.profile', '--value', 'old']);
+        await expect(run(['refresh', 'aws.profile'])).rejects.toThrow(/--value|value/i);
+    });
+    it('use switches active environment (RF-2.2)', async () => {
+        await run(['use', 'staging']);
+        expect((0, store_1.getActiveEnvironmentName)()).toBe('staging');
+        await run(['set', 'repos.root', '--value', '/staging/repos']);
+        expect((0, store_1.valuesPath)('staging')).toContain(`${path_1.default.sep}staging${path_1.default.sep}values.json`);
+        expect((0, store_1.readValues)('staging')['repos.root'].value).toBe('/staging/repos');
+    });
+    it('set unknown id errors listing consulted roots', async () => {
+        await expect(run(['set', 'no.such.fact', '--value', 'x'])).rejects.toThrow(/no\.such\.fact/);
+        await expect(run(['set', 'no.such.fact', '--value', 'x'])).rejects.toThrow(/test-registry/);
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('set rejects empty path and leaves store unchanged', async () => {
+        await expect(run(['set', 'repos.root', '--value', ''])).rejects.toThrow(/path|empty|value/i);
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('set rejects invalid enum value', async () => {
+        await expect(run(['set', 'env.kind', '--value', 'qa'])).rejects.toThrow(/enum|dev|prod/i);
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('set never imports child_process for resolution (RF-3.3)', () => {
+        const src = fs_1.default.readFileSync(path_1.default.join(__dirname, '../../../src/commands/env/index.ts'), 'utf-8');
+        expect(src).not.toMatch(/child_process/);
+        expect(src).not.toMatch(/\bexecSync\b|\bspawnSync\b|\bexecFileSync\b/);
+    });
+    it('set without --value on TTY uses promptFn (RF-3.3)', async () => {
+        const prompts = [];
+        await run(['set', 'repos.root'], () => catalog, {
+            stdinIsTTY: () => true,
+            promptValue: (q) => {
+                prompts.push(q);
+                return '/prompted/repos';
+            },
+        });
+        expect(prompts.length).toBeGreaterThanOrEqual(1);
+        expect((0, store_1.readValues)('default')['repos.root'].value).toBe('/prompted/repos');
+    });
+    it('set without --value when not TTY keeps requireValue error (RF-3.3)', async () => {
+        await expect(run(['set', 'repos.root'], () => catalog, { stdinIsTTY: () => false })).rejects.toThrow(/--value|value/i);
+    });
+    it('refresh --all on TTY prompts each store id via promptFn', async () => {
+        await run(['set', 'repos.root', '--value', '/old']);
+        await run(['set', 'aws.profile', '--value', 'old-profile']);
+        const seen = [];
+        const answers = {
+            'repos.root': '/new',
+            'aws.profile': 'new-profile',
+        };
+        await run(['refresh', '--all'], () => catalog, {
+            stdinIsTTY: () => true,
+            promptValue: (q) => {
+                const id = Object.keys(answers).find((k) => q.includes(k));
+                if (!id)
+                    throw new Error(`unexpected prompt: ${q}`);
+                seen.push(id);
+                return answers[id];
+            },
+        });
+        expect(seen.sort()).toEqual(['aws.profile', 'repos.root']);
+        expect((0, store_1.readValues)('default')['repos.root'].value).toBe('/new');
+        expect((0, store_1.readValues)('default')['aws.profile'].value).toBe('new-profile');
+    });
+    it('refresh --all when not TTY keeps clear error', async () => {
+        await run(['set', 'repos.root', '--value', '/old']);
+        await expect(run(['refresh', '--all'], () => catalog, { stdinIsTTY: () => false })).rejects.toThrow(/--all|interactive|factId|--value|TTY/i);
+    });
+    it('inject prints buildInjection JSON (default reference)', async () => {
+        await run(['set', 'repos.root', '--value', '/r']);
+        const { out } = await run(['inject']);
+        const parsed = JSON.parse(out.trim());
+        expect(parsed.mode).toBe('reference');
+        expect(parsed.storePath).toContain('values.json');
+        expect(parsed.factIds).toEqual(expect.arrayContaining(['repos.root']));
+        expect(parsed.values).toBeUndefined();
+    });
+    it('inject --mode context includes fresh context values when catalog allows', async () => {
+        const contextCatalog = {
+            schemaVersion: 1,
+            facts: {
+                'team.color': {
+                    valueType: 'string',
+                    resolution: 'prompt',
+                    durability: 'durable',
+                    inject: 'context',
+                },
+            },
+        };
+        await run(['set', 'team.color', '--value', 'blue'], () => contextCatalog);
+        const { out } = await run(['inject', '--mode', 'context'], () => contextCatalog);
+        const parsed = JSON.parse(out.trim());
+        expect(parsed.mode).toBe('context');
+        expect(parsed.values).toEqual({ 'team.color': 'blue' });
+    });
+    it('mergeFactDefinitions refuses to weaken volatile → durable (secret revive)', () => {
+        const into = {
+            'aws.token': {
+                valueType: 'string',
+                resolution: 'prompt',
+                durability: 'volatile',
+                inject: 'context',
+                ttl: 60,
+            },
+        };
+        (0, env_1.mergeFactDefinitions)(into, {
+            'aws.token': {
+                valueType: 'string',
+                resolution: 'prompt',
+                durability: 'durable',
+                inject: 'context',
+            },
+        });
+        expect(into['aws.token'].durability).toBe('volatile');
+        expect(into['aws.token'].ttl).toBe(60);
+    });
+});

package/dist/tests/commands/preflight/preflight.test.js

@@ -397,6 +397,19 @@ describe('preflight', () => {
         expect(execution.remedy).toContain('awm sensors init');
         expect(execution.remedy).not.toContain('named sensor');
     });
+    it('does not treat overall=pass as unconditional green when invalidEntries are present', async () => {
+        const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
+        mockRunSensors.mockResolvedValue({
+            overall: 'pass',
+            sensors: [{ name: 'good', status: 'pass', errors: [] }],
+            invalidEntries: [{ name: 'broken', reason: 'sensors.broken.formatter is not a registered formatter id' }],
+        });
+        const report = await (0, checks_1.preflight)(dir, { verifySensors: true });
+        const execution = check(report, 'sensors-execution');
+        expect(execution.ok).toBe(false);
+        expect(execution.detail).toMatch(/invalidEntries|broken/i);
+        expect(execution.detail).not.toBe('all selected sensors completed with pass');
+    });
     it('reports not_configured when no sensor manifest exists', async () => {
         // The team-rollout case: a developer clones the repo and never runs
         // `awm sensors init`. Today nothing notices until an unattended run is already
@@ -813,4 +826,112 @@ describe('preflight', () => {
         expect(check(report, 'manifest').detail).not.toContain('no .awm/sensors.json');
         expect(check(report, 'tools')).toBeUndefined();
     });
+    describe('project-declared diagnostics (S3)', () => {
+        it('does not claim not-valid-JSON when JSON parses but a project field fails schema (RF-4.1/4.2)', async () => {
+            const dir = make({
+                manifest: {
+                    schemaVersion: 3,
+                    mode: 'project-sensors',
+                    sensors: {
+                        broken: {
+                            source: 'project',
+                            enabled: true,
+                            command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                            formatter: 'not-a-formatter',
+                        },
+                    },
+                },
+            });
+            const report = await (0, checks_1.preflight)(dir);
+            const manifestCheck = check(report, 'manifest');
+            expect(manifestCheck.ok).toBe(false);
+            expect(manifestCheck.detail).not.toBe('.awm/sensors.json is not valid JSON');
+            expect(manifestCheck.detail).not.toMatch(/not valid JSON/i);
+            expect(manifestCheck.detail).toMatch(/broken/);
+            expect(manifestCheck.detail).toMatch(/formatter/);
+            expect(report.reason).toMatch(/schema-invalid/i);
+        });
+        it('still reports not-valid-JSON for truly broken JSON (RF-4.1)', async () => {
+            const dir = make({ manifest: '{ not json' });
+            const report = await (0, checks_1.preflight)(dir);
+            expect(check(report, 'manifest').detail).toContain('not valid JSON');
+        });
+        it('does not recommend awm sensors init as the first remedy for project schema invalidity (RF-3.3)', async () => {
+            const dir = make({
+                manifest: {
+                    schemaVersion: 3,
+                    mode: 'project-sensors',
+                    sensors: {
+                        broken: {
+                            source: 'project',
+                            enabled: true,
+                            command: { executable: 'terraform', resolution: 'path', args: ['fmt'] },
+                            formatter: 'not-a-formatter',
+                        },
+                    },
+                },
+            });
+            const remedy = check(await (0, checks_1.preflight)(dir), 'manifest').remedy ?? '';
+            const firstLine = remedy.split('\n')[0] ?? remedy;
+            expect(firstLine).not.toMatch(/awm sensors init/i);
+            // RF-3.3 positive: first remedy names repair of the entry/field, not regen.
+            expect(firstLine).toMatch(/repair|entry|field/i);
+        });
+        it('uses an only-project-honest tools remedy when sensors are empty and pack is null', async () => {
+            const dir = make({
+                manifest: {
+                    schemaVersion: 3,
+                    mode: 'project-sensors',
+                    sensors: {},
+                },
+            });
+            const report = await (0, checks_1.preflight)(dir);
+            const tools = check(report, 'tools');
+            expect(tools.ok).toBe(false);
+            expect(tools.remedy ?? '').not.toMatch(/['"]null['"]/);
+            expect(tools.remedy ?? '').not.toMatch(/awm update/i);
+            expect(tools.remedy ?? '').not.toMatch(/registry has no pack/i);
+            expect(tools.remedy ?? '').toMatch(/source:"project"|declare a pack/i);
+        });
+        it('accepts only-project READY status without inventing a pack id (RF-2.8)', async () => {
+            const pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-preflight-only-project-path-'));
+            const previousPath = process.env.PATH;
+            try {
+                fs_1.default.writeFileSync(path_1.default.join(pathDir, 'terraform'), '#!/bin/sh\nexit 0\n');
+                fs_1.default.chmodSync(path_1.default.join(pathDir, 'terraform'), 0o755);
+                process.env.PATH = pathDir;
+                const dir = make({
+                    manifest: {
+                        schemaVersion: 3,
+                        mode: 'project-sensors',
+                        sensors: {
+                            'iac-format': {
+                                source: 'project',
+                                enabled: true,
+                                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                                formatter: 'exit-code',
+                            },
+                        },
+                    },
+                });
+                const report = await (0, checks_1.preflight)(dir);
+                const manifestCheck = check(report, 'manifest');
+                expect(manifestCheck.ok).toBe(true);
+                expect(manifestCheck.detail).not.toMatch(/sensor authority is unavailable/i);
+                expect(manifestCheck.detail).not.toMatch(/pack ['"]?generic['"]?/i);
+                // only-project READY must say so — loose "sensors enabled" alone is pack wording.
+                expect(manifestCheck.detail).toMatch(/only-project/i);
+                expect(manifestCheck.detail).toMatch(/project-declared/i);
+                expect(check(report, 'tools').ok).toBe(true);
+                expect(report.mode).toBe('project-sensors');
+            }
+            finally {
+                if (previousPath === undefined)
+                    delete process.env.PATH;
+                else
+                    process.env.PATH = previousPath;
+                fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+            }
+        });
+    });
 });