agentic-workflow-manager 3.13.4 → 3.13.6

package/dist/tests/core/frontmatter-description-vs-yaml.test.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Test DIFERENCIAL: readFrontmatterDescription (parser a mano, cero deps de
+// runtime) contra js-yaml (parser YAML real, devDependency solo de test).
+//
+// Por que existe: el repo parsea el frontmatter a mano a proposito (ver
+// core/export/transform.ts — "sin parser YAML a proposito, YAGNI, cero deps").
+// Esa decision es sostenible SOLO si algo verifica que la implementacion a
+// mano coincide con la semantica YAML real; si no, cada forma valida que el
+// parser casero no contempla es un bug esperando a un skill que la use. Ya
+// paso dos veces: (1) un block scalar (`description: >-`) se colapsaba a
+// vacio, rompiendo `awm add -a cursor|copilot` y abortando `awm export`
+// entero contra un skill real del registry; (2) este mismo test diferencial
+// descubrio que un escalar single-quoted no deshacia el escape YAML de `'`
+// (duplicado: `''`), devolviendo "it''s" en vez de "it's".
+//
+// js-yaml es devDependency: NO entra en el bundle que instalan los usuarios.
+// La regla de cero dependencias de runtime queda intacta — de hecho este test
+// es lo que la hace defendible.
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const discovery_1 = require("../../src/core/discovery");
+/** Cada caso es un bloque de frontmatter cuyo `description` debe resolverse
+ *  IGUAL que como lo hace un parser YAML real. Sin valores esperados
+ *  hardcodeados a proposito: la referencia es js-yaml, asi que el test no
+ *  puede "envejecer" hacia una expectativa equivocada. */
+const CASES = [
+    ['folded (>)', 'description: >\n  a\n  b'],
+    ['folded strip (>-)', 'description: >-\n  a\n  b'],
+    ['folded keep (>+)', 'description: >+\n  a\n  b'],
+    ['literal (|)', 'description: |\n  a\n  b'],
+    ['literal strip (|-)', 'description: |-\n  a\n  b'],
+    ['folded con parrafos', 'description: >-\n  a\n\n  b'],
+    ['literal con parrafos', 'description: |-\n  a\n\n  b'],
+    ['bloque seguido de otra clave', 'description: >-\n  solo\nname: x'],
+    ['bloque con indent 4', 'description: >-\n    a\n    b'],
+    ['bloque con indent explicito', 'description: >2\n  a\n  b'],
+    ['bloque de una sola linea', 'description: >-\n  sola'],
+    ['bloque con colon adentro', 'description: >-\n  clave: valor'],
+    ['bloque con hash adentro', 'description: >-\n  a #no-es-comentario'],
+    ['plain', 'description: hola mundo'],
+    ['plain con guion', 'description: usa - guiones'],
+    ['double-quoted con colon', 'description: "hola: mundo"'],
+    ['double-quoted con comilla escapada', 'description: "dice \\"hola\\""'],
+    ['double-quoted con \\n', 'description: "a\\nb"'],
+    ['double-quoted con backslash', 'description: "c:\\\\\\\\ruta"'],
+    ['single-quoted con apostrofe escapado', "description: 'it''s aqui'"],
+    ['single-quoted con doble apostrofe', "description: 'a''''b'"],
+    ['single-quoted con colon', "description: 'clave: valor'"],
+    ['double-quoted con em-dash', 'description: "em — dash"'],
+    // Casos que una revision adversarial encontro y los tests a mano no cubrian.
+    ['folded con lineas MAS indentadas (no se pliegan)', 'description: >-\n  intro\n    - item uno\n    - item dos\n  outro'],
+    ['folded con indentacion irregular', 'description: >\n  foo\n   bar\n  baz'],
+    ['indicador con comentario final', 'description: >- # nota al margen\n  el texto real'],
+    ['literal con comentario final', 'description: |- # nota\n  linea'],
+    ['clave description indentada NO gana sobre la real', 'metadata:\n  description: nota interna\ndescription: la verdadera'],
+    ['description dentro del contenido de otro bloque', 'example: |\n  description: falsa\ndescription: la verdadera'],
+    ['plain con comentario final', 'description: hola mundo # un comentario'],
+    ['plain con hash pegado (NO es comentario)', 'description: usar C# y F#'],
+    ['plain multilinea (se pliega como folded)', 'description: primera\n  segunda\n  tercera'],
+    ['quoted con hash adentro (literal)', 'description: "tiene # adentro"'],
+    // Segunda tanda de revision adversarial: espacios, blancos consecutivos y
+    // escalares entrecomillados que cierran en una linea posterior.
+    ['blancos consecutivos en folded', 'description: >-\n  a\n\n\n  b'],
+    ['espacios finales dentro de un folded', 'description: >-\n  a   \n  b'],
+    ['linea solo-espacios dentro de un folded', 'description: >-\n  a\n   \n  b'],
+    ['double-quoted multilinea', 'description: "hola\n  mundo"'],
+    ['single-quoted multilinea', "description: 'hola\n  mundo'"],
+    ['double-quoted con comentario final', 'description: "x" # comentario'],
+    ['single-quoted con comentario final', "description: 'y' # comentario"],
+    ['single-quoted con apostrofe y comentario', "description: 'it''s aqui' # nota"],
+];
+/** Formas que YAML RECHAZA: no hay valor correcto que devolver, y devolver el
+ *  indicador crudo como si fuera la descripcion seria peor que no devolver
+ *  nada (se publicaria en el artefacto). El contrato aca es '' — que hace
+ *  fallar fuerte a parseSkillSource y claudeAiTransform. */
+const INVALID_CASES = [
+    ['indicador con indent 0', 'description: >0\n  a'],
+    ['indicador con indent de 2 digitos', 'description: >12\n  a'],
+    ['indicador con basura pegada', 'description: >-basura\n  a'],
+    ['indicador con comentario sin espacio', 'description: >-#c\n  a'],
+];
+describe('readFrontmatterDescription coincide con un parser YAML real (js-yaml)', () => {
+    it.each(CASES)('%s', (_name, frontmatter) => {
+        const parsed = js_yaml_1.default.load(frontmatter);
+        // Guard del propio fixture: si js-yaml no lo lee como string, el caso
+        // esta mal escrito y el test seria vacuo — que falle fuerte.
+        expect(typeof parsed.description).toBe('string');
+        const expected = parsed.description.trim();
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).toBe(expected);
+    });
+    it.each(INVALID_CASES)('%s: YAML lo rechaza, nosotros devolvemos vacio (nunca el indicador crudo)', (_name, frontmatter) => {
+        // Guard del fixture: si js-yaml LO ACEPTARA, el caso esta mal clasificado
+        // y este test seria vacuo — que falle fuerte.
+        expect(() => js_yaml_1.default.load(frontmatter)).toThrow();
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).toBe('');
+    });
+    it('resuelve el SKILL.md real del registry igual que js-yaml (extract-design-md, el caso que origino el bug)', () => {
+        // Forma exacta del skill real de awm-baseline-registry que rompia
+        // `awm add -a cursor|copilot` y `awm export frontend`.
+        const frontmatter = [
+            'name: extract-design-md',
+            'version: "1.0.1"',
+            'description: >-',
+            '  Extract a comprehensive design system (DESIGN.md) directly from frontend source',
+            '  code — React, Vue, Svelte, Angular, plain HTML/CSS, or any web framework.',
+            'allowed-tools:',
+            '  - "Bash"',
+        ].join('\n');
+        const expected = (js_yaml_1.default.load(frontmatter).description).trim();
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).toBe(expected);
+        // Y no absorbio la clave siguiente ni sus items indentados.
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).not.toContain('allowed-tools');
+        expect((0, discovery_1.readFrontmatterDescription)(frontmatter)).not.toContain('Bash');
+    });
+});

package/dist/tests/core/init/all-baseline-bundles.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// `awm init` and `awm update` disagreed about what "the baseline" is.
+//
+//   init   (steps.ts)          bundles.find(b => b.scope === 'baseline')     ← the FIRST one
+//   update (reconciliation.ts) bundles.filter(b => b.scope === 'baseline' …) ← all of them
+//
+// A registry shipping two baseline bundles therefore installed one on `awm init` and
+// two on the next `awm update` — and the diagnostic that decides whether the baseline
+// is satisfied used `find` too, so it agreed with init and disagreed with update. The
+// second bundle appeared out of nowhere on an unrelated command, and nothing before
+// that had reported it missing.
+//
+// `filter` is the correct reading: `scope: 'baseline'` is a property a bundle HAS, not
+// a slot only one bundle can occupy.
+const steps_1 = require("../../../src/core/init/steps");
+function bundle(name, scope) {
+    return {
+        name, description: '', version: '1.0.0', scope, visibility: 'public',
+        dependsOn: [], skills: [], workflows: [], agents: [], source: `bundles/${name}`,
+    };
+}
+function deps(bundles) {
+    const installs = [];
+    const d = {
+        cwd: '/repo',
+        agent: 'claude-code',
+        enabledAgents: ['claude-code'],
+        bundles,
+        installMethod: 'symlink',
+        registryRoot: '',
+        contentDir: '',
+        sensorPacksRoot: '',
+        ctx: {
+            machine: { devCore: { present: false, brokenLinks: [] } },
+            project: null,
+        },
+        actions: { installBundle: (o) => { installs.push(o.bundleName); } },
+    };
+    return { d, installs };
+}
+describe('awm init installs every baseline bundle, like awm update reconciles every one', () => {
+    it('installs all of them, not just the first', () => {
+        const { d, installs } = deps([
+            bundle('dev-core', 'baseline'),
+            bundle('team-baseline', 'baseline'),
+            bundle('frontend', 'project'),
+        ]);
+        const result = (0, steps_1.stepDevCore)(d);
+        expect(installs).toEqual(['dev-core', 'team-baseline']);
+        expect(result.action).toBe('applied');
+    });
+    it('installs nothing from a non-baseline scope', () => {
+        const { d, installs } = deps([bundle('dev-core', 'baseline'), bundle('extras', 'ambient')]);
+        (0, steps_1.stepDevCore)(d);
+        expect(installs).toEqual(['dev-core']);
+    });
+    it('still skips entirely when the baseline is already satisfied', () => {
+        const { d, installs } = deps([bundle('dev-core', 'baseline'), bundle('team-baseline', 'baseline')]);
+        d.ctx.machine.devCore.present = true;
+        expect((0, steps_1.stepDevCore)(d).action).toBe('skipped');
+        expect(installs).toEqual([]);
+    });
+});

package/dist/tests/core/init/context-injection-no-project.test.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `stepContextInjection` is a MACHINE-level step — it runs even when `ctx.project`
+// is null. For providers whose context delivery is project-scope (managed-agents-md
+// with `globalPath: null` — Cursor, Copilot) it then fell back to writing at `d.cwd`:
+//
+//     $ cd ~/scratch && awm init -a copilot     # not a project: no .git, no package.json
+//     ~/scratch/AGENTS.md                       ← written
+//     ~/scratch/.awm/context/awm-context.md     ← written
+//
+// `planInitMutationTargets` enumerates both of those paths only inside
+// `if (projectRoot)`, so with no project root neither entered the backup session. A
+// later failed step rolled back everything that WAS enumerated and left these two
+// behind — while the outcome reported `rolledBack: true` and listed `restoredFiles`,
+// i.e. claimed a clean restore it had not performed.
+//
+// `--machine-only` reached the same place from the other side: it nulls `ctx.project`
+// deliberately, so the step took the `?? d.cwd` branch even inside a real project.
+//
+// Two different situations were being read as one. Running in a directory the user
+// means as their project but which has no marker yet is legitimate — Copilot has no
+// other channel, so removing that write would leave it with no context at all. What
+// was wrong is that the path was never enumerated, so it survived rollback; that is
+// fixed in mutation-targets, which now covers `cwd` for these providers regardless of
+// whether a project root was found.
+//
+// `--machine-only` is the case that must not write at all: it nulls `ctx.project` on
+// purpose, and this step read that as "no project found" and wrote into cwd anyway —
+// under the one flag whose entire promise is that it won't touch the project.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const steps_1 = require("../../../src/core/init/steps");
+const mutation_targets_1 = require("../../../src/core/init/mutation-targets");
+const materializer_1 = require("../../../src/core/context/materializer");
+function deps(agent, cwd, projectRoot, machineOnly = false) {
+    const installed = [];
+    const d = {
+        cwd,
+        agent,
+        enabledAgents: [agent],
+        bundles: [],
+        installMethod: 'symlink',
+        registryRoot: '',
+        contentDir: '',
+        sensorPacksRoot: '',
+        machineOnly,
+        ctx: {
+            machine: {},
+            project: projectRoot ? { root: projectRoot } : null,
+        },
+        actions: {
+            contextStatus: () => 'absent',
+            installContext: (op) => { installed.push(op); },
+        },
+    };
+    return { d, installed };
+}
+describe('project-scope context injection without a project', () => {
+    let cwd;
+    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-noproj-')); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    it.each(['copilot', 'cursor'])('%s: writes nothing at all under --machine-only', (agent) => {
+        const { d, installed } = deps(agent, cwd, null, true);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(installed).toEqual([]);
+        expect(result.action).toBe('skipped');
+        expect(result.detail).toMatch(/machine-only/i);
+    });
+    it.each(['copilot', 'cursor'])('%s: still delivers into an unmarked cwd — its only channel — now that the path is backed up', (agent) => {
+        const { d, installed } = deps(agent, cwd, null);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(result.action).toBe('applied');
+        expect(installed[0].projectRoot).toBe(cwd);
+        // the write is only safe because mutation-targets enumerates it — asserted below
+        expect((0, mutation_targets_1.planInitMutationTargets)({ cwd, agent, bundles: [] }))
+            .toContain(path_1.default.join(cwd, 'AGENTS.md'));
+    });
+    it('leaves a GLOBAL-scope provider untouched by --machine-only', () => {
+        // --machine-only excludes the project, not the machine. Codex's context is
+        // machine-global, so it must still be installed.
+        const { d, installed } = deps('codex', cwd, null, true);
+        expect((0, steps_1.stepContextInjection)(d).action).toBe('applied');
+        expect(installed).toHaveLength(1);
+    });
+    it('still injects for a local-scope provider when a project root IS known', () => {
+        const { d, installed } = deps('copilot', cwd, cwd);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(result.action).toBe('applied');
+        expect(installed).toHaveLength(1);
+        expect(installed[0].projectRoot).toBe(cwd);
+    });
+    it('leaves global-scope injection (codex) alone — it needs no project', () => {
+        const { d, installed } = deps('codex', cwd, null);
+        const result = (0, steps_1.stepContextInjection)(d);
+        expect(result.action).toBe('applied');
+        expect(installed).toHaveLength(1);
+        expect(installed[0].scope).toBe('global');
+    });
+});
+describe('mutation-targets covers the local-scope context paths independently', () => {
+    let cwd;
+    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-noproj-mt-')); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true, force: true }); });
+    it.each(['copilot', 'cursor'])('%s: enumerates AGENTS.md and .awm/context even with no project root', (agent) => {
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd, agent, bundles: [] });
+        expect(targets).toContain(path_1.default.join(cwd, 'AGENTS.md'));
+        expect(targets).toContain((0, materializer_1.projectContextPath)(cwd));
+    });
+    it('does not invent those targets for a provider that never writes them', () => {
+        const targets = (0, mutation_targets_1.planInitMutationTargets)({ cwd, agent: 'claude-code', bundles: [] });
+        expect(targets).not.toContain((0, materializer_1.projectContextPath)(cwd));
+    });
+});

package/dist/tests/core/init/orchestrator.test.js

@@ -58,7 +58,7 @@ describe('runInitSteps — orchestrator', () => {
     function buildDeps(cwd) {
         const { gatherContext } = require('../../../src/core/diagnostics/context');
         const { discoverAllBundles } = require('../../../src/core/bundles');
-        const { contentRoots, REGISTRIES_DIR } = require('../../../src/core/registries');
+        const { contentRoots, registriesDir } = require('../../../src/core/registries');
         const { defaultActions } = require('../../../src/core/init/steps');
         // Seed content at ~/.awm/registries/baseline (content root IS the registry root).
         const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');

package/dist/tests/core/init/steps-registry-sync.test.js

@@ -57,7 +57,7 @@ describe('stepCache — registry sync error results', () => {
         const ctx = {
             machine: {
                 registryCache: { present: false },
-                hook: { present: true, degraded: false },
+                hook: { present: true, degraded: false, applicable: true },
                 devCore: { present: true, brokenLinks: [] },
                 ambient: { wanted: [], installed: [] },
                 contextInjection: [],

package/dist/tests/core/init/steps.test.js

@@ -19,7 +19,7 @@ function bundle(name, scope, skills) {
 function machine() {
     return {
         registryCache: { present: true, gitState: 'clean' },
-        hook: { present: true, degraded: false },
+        hook: { present: true, degraded: false, applicable: true },
         devCore: { present: true, brokenLinks: [] },
         ambient: { wanted: [], installed: [] },
         contextInjection: [],
@@ -31,6 +31,7 @@ function project(over = {}) {
         root: '/repo',
         profile: { present: true, extensions: [] },
         activeBundles: { expected: [], linked: [], broken: [] },
+        orphanLinks: { repairable: [], dead: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },
@@ -101,14 +102,14 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
     it('hook installs when absent', () => {
         const a = spies();
         const m = machine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installHook).toHaveBeenCalled();
     });
     it('hook reinstalls when present but degraded', () => {
         const a = spies();
         const m = machine();
-        m.hook = { present: true, degraded: true };
+        m.hook = { present: true, degraded: true, applicable: true };
         expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installHook).toHaveBeenCalled();
     });
@@ -123,7 +124,7 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
     it('hook skips (not calls installHook) for an agent with no hook mechanism', () => {
         const a = spies();
         const m = machine();
-        m.hook = { present: false };
+        m.hook = { present: false, applicable: true };
         const r = (0, steps_1.stepHook)(deps({ machine: m, project: null }, a, { agent: 'opencode', enabledAgents: ['opencode'] }));
         expect(r.action).toBe('skipped');
         expect(a.installHook).not.toHaveBeenCalled();
@@ -533,7 +534,7 @@ describe('stepContextInjection', () => {
     it('installs Copilot context at local scope with projectRoot (no global AGENTS.md-equivalent)', () => {
         const a = spies();
         a.contextStatus.mockReturnValue('absent');
-        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/repo' }));
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: project({ root: '/repo' }) }, a, { agent: 'copilot', cwd: '/repo' }));
         expect(r.action).toBe('applied');
         expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
     });
@@ -550,6 +551,11 @@ describe('stepContextInjection', () => {
         expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
     });
     it('falls back to raw cwd when no project was discovered', () => {
+        // Legitimate: Copilot has no channel other than a project AGENTS.md, and a
+        // directory without .git/package.json is still where the user is working. What
+        // made this a rollback hole was mutation-targets.ts enumerating that path only
+        // inside `if (projectRoot)` — fixed there; see
+        // tests/core/init/context-injection-no-project.test.ts.
         const a = spies();
         a.contextStatus.mockReturnValue('absent');
         const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/nowhere' }));

package/dist/tests/core/path-resolution-no-shell.test.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// SECURITY regression: `resolveOnPath` used to interpolate its argument into a
+// SHELL string (`command -v ${bin}` / `where ${bin}`) and run it through
+// execSync. The argument is the first token of a sensor's `cmd`, which comes
+// from `.awm/sensors.json` — a file that is COMMITTED IN THE REPO and also
+// regenerated from a registry sensor-pack's `defaultCmd`. So both a cloned
+// untrusted repo and a third-party registry could reach it.
+//
+// The token cannot contain whitespace (it is a split token), but that stops
+// nothing: `${IFS}` and `$(...)` sidestep it entirely. Confirmed exploit on the
+// real binary — `awm sensors status` (and `awm preflight`) executed an attacker
+// command and then reported the sensor as HEALTHY, because the injected command
+// exited 0:
+//
+//     {"sensors":{"lint":{"cmd":"foo;touch${IFS}/tmp/PWNED","fast":true}}}
+//     $ awm sensors status      # -> /tmp/PWNED created, status "✔ HEALTHY"
+//
+// `awm sensors status` and `awm preflight` are commands a user reasonably
+// expects to be INERT — read-only inspection. The fix removes the shell
+// entirely: PATH is resolved in-process, so there is no interpreter to inject
+// into, on any platform.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../../src/core/paths");
+describe('resolveOnPath: sin shell, inmune a inyeccion', () => {
+    const realPlatform = process.platform;
+    let binDir;
+    let originalPath;
+    beforeEach(() => {
+        binDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pathres-'));
+        originalPath = process.env.PATH;
+        process.env.PATH = binDir;
+    });
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: realPlatform });
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        fs_1.default.rmSync(binDir, { recursive: true, force: true });
+    });
+    function setPlatform(p) {
+        Object.defineProperty(process, 'platform', { value: p });
+    }
+    /** Un binario "real" en el PATH falso. */
+    function putBinary(name, mode = 0o755) {
+        const p = path_1.default.join(binDir, name);
+        fs_1.default.writeFileSync(p, '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(p, mode);
+        return p;
+    }
+    it('encuentra un binario real presente en PATH', () => {
+        setPlatform('linux');
+        putBinary('mytool');
+        expect((0, paths_1.resolveOnPath)('mytool')).toBe(true);
+    });
+    it('devuelve false para un binario ausente', () => {
+        setPlatform('linux');
+        expect((0, paths_1.resolveOnPath)('definitivamente-no-existe')).toBe(false);
+    });
+    it('NO ejecuta un payload de inyeccion — el efecto lateral jamas ocurre (regresion de seguridad)', () => {
+        setPlatform('linux');
+        const marker = path_1.default.join(binDir, 'PWNED');
+        // El mismo payload confirmado contra el binario real.
+        const payload = `foo;touch\${IFS}${marker}`;
+        expect((0, paths_1.resolveOnPath)(payload)).toBe(false);
+        expect(fs_1.default.existsSync(marker)).toBe(false);
+    });
+    it.each([
+        ['sustitucion de comando', 'foo$(touch MARKER)'],
+        ['backticks', 'foo`touch MARKER`'],
+        ['encadenado con &&', 'foo&&touch'],
+        ['pipe', 'foo|touch'],
+        ['redireccion', 'foo>MARKER'],
+        ['newline embebido', 'foo\ntouch MARKER'],
+        ['expansion de variable', '$HOME'],
+    ])('trata %s como un nombre literal, nunca como sintaxis', (_n, payload) => {
+        setPlatform('linux');
+        // No existe un archivo con ese nombre literal => false, y nada se ejecuta.
+        expect((0, paths_1.resolveOnPath)(payload)).toBe(false);
+    });
+    // Solo donde el filesystem PUEDE expresar la premisa. `setPlatform('linux')` cambia
+    // lo que hace el codigo, no lo que hace el disco: en un runner Windows `chmod 0o644`
+    // no quita ningun bit de ejecucion (no existe), asi que `accessSync(X_OK)` aprueba el
+    // archivo y el test fallaba sobre un producto que se comporta bien. La rama win32 —
+    // "no exige bit de ejecucion" — la cubre su propio caso mas abajo, que SI es
+    // observable ahi.
+    const itPosix = realPlatform === 'win32' ? it.skip : it;
+    itPosix('en POSIX exige el bit de ejecucion — un archivo no ejecutable no es un binario resoluble', () => {
+        setPlatform('linux');
+        putBinary('noexec', 0o644);
+        expect((0, paths_1.resolveOnPath)('noexec')).toBe(false);
+    });
+    it('en win32 resuelve por PATHEXT, incluyendo los shims .cmd de npm (regresion: R1, bug publicado en v3.9.0)', () => {
+        setPlatform('win32');
+        // En win32 el usuario escribe `eslint`, y lo que existe en disco es
+        // `eslint.cmd` — no resolverlo fue un bug real que rompia los sensores.
+        fs_1.default.writeFileSync(path_1.default.join(binDir, 'eslint.cmd'), '@echo off\r\n');
+        process.env.PATHEXT = '.COM;.EXE;.BAT;.CMD';
+        expect((0, paths_1.resolveOnPath)('eslint')).toBe(true);
+        expect((0, paths_1.resolveOnPath)('noexiste')).toBe(false);
+    });
+    it('en win32 no exige bit de ejecucion (no existe ese concepto ahi)', () => {
+        setPlatform('win32');
+        fs_1.default.writeFileSync(path_1.default.join(binDir, 'tool.exe'), '');
+        process.env.PATHEXT = '.COM;.EXE;.BAT;.CMD';
+        expect((0, paths_1.resolveOnPath)('tool')).toBe(true);
+    });
+    it('un nombre con separador de ruta se chequea como ruta directa, sin recorrer PATH', () => {
+        // La plataforma REAL, no una simulada: el invariante es "un nombre que trae el
+        // separador de SU plataforma se resuelve como ruta". Fijar 'linux' mientras el
+        // disco entrega `D:\...\directo` mezclaba las dos mitades — el codigo buscaba
+        // '/' y la ruta traia '\\' — y fallaba por la contradiccion del arreglo, no por
+        // el producto. Asi el caso corre de verdad en los dos sistemas operativos.
+        setPlatform(realPlatform);
+        const abs = putBinary('directo');
+        expect((0, paths_1.resolveOnPath)(abs)).toBe(true);
+        expect((0, paths_1.resolveOnPath)(path_1.default.join(binDir, 'no-esta'))).toBe(false);
+    });
+    it('entradas vacias o no-string no resuelven ni crashean', () => {
+        setPlatform('linux');
+        expect((0, paths_1.resolveOnPath)('')).toBe(false);
+        expect((0, paths_1.resolveOnPath)('   ')).toBe(false);
+        expect((0, paths_1.resolveOnPath)(undefined)).toBe(false);
+    });
+    it('un PATH ausente no crashea', () => {
+        setPlatform('linux');
+        delete process.env.PATH;
+        expect((0, paths_1.resolveOnPath)('cualquiera')).toBe(false);
+    });
+});

package/dist/tests/core/paths.test.js

@@ -5,10 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const child_process_1 = require("child_process");
 const paths_1 = require("../../src/core/paths");
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
-const mockExecSync = child_process_1.execSync;
 describe('core/paths', () => {
     let origHome;
     let origAwmHome;
@@ -16,7 +13,6 @@ describe('core/paths', () => {
     beforeEach(() => {
         origHome = process.env.HOME;
         origAwmHome = process.env.AWM_HOME;
-        mockExecSync.mockReset();
     });
     afterEach(() => {
         if (origHome === undefined)
@@ -106,34 +102,11 @@ describe('core/paths', () => {
         setPlatform('linux');
         expect(() => (0, paths_1.noteWindowsCaveat)(throwingLog)).not.toThrow();
     });
-    describe('resolveOnPath', () => {
-        it('uses `command -v` on POSIX and returns true when the binary resolves', () => {
-            setPlatform('linux');
-            mockExecSync.mockImplementation(((cmd) => {
-                if (cmd === 'command -v semgrep')
-                    return Buffer.from('/usr/bin/semgrep');
-                throw new Error(`not found: ${cmd}`);
-            }));
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(true);
-        });
-        it('returns false on POSIX when `command -v` fails to resolve the binary', () => {
-            setPlatform('linux');
-            mockExecSync.mockImplementation(() => { throw new Error('not found'); });
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(false);
-        });
-        it('uses `where` on win32, not `command -v`', () => {
-            setPlatform('win32');
-            mockExecSync.mockImplementation(((cmd) => {
-                if (cmd === 'where semgrep')
-                    return Buffer.from('C:\\tools\\semgrep.exe');
-                throw new Error(`not found: ${cmd}`);
-            }));
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(true);
-        });
-        it('returns false on win32 when `where` cannot find the binary', () => {
-            setPlatform('win32');
-            mockExecSync.mockImplementation(() => { throw new Error('not found'); });
-            expect((0, paths_1.resolveOnPath)('semgrep')).toBe(false);
-        });
-    });
+    // `resolveOnPath` ya no invoca un shell (ni ningun subproceso): resuelve PATH
+    // en proceso. Los tests que vivian aca mockeaban `execSync` y verificaban las
+    // strings `command -v X` / `where X`, o sea la implementacion removida — y dos
+    // de ellos ademas pasaban por accidente en cualquier maquina que tuviera el
+    // binario del fixture instalado de verdad. Su reemplazo, con PATH controlado y
+    // el exploit de inyeccion como ancla, esta en
+    // tests/core/path-resolution-no-shell.test.ts.
 });