agentic-workflow-manager 3.13.5 → 3.13.7

package/dist/src/commands/watch/index.js

@@ -5,6 +5,7 @@ const child_process_1 = require("child_process");
 const init_1 = require("./init");
 const supervisor_1 = require("./supervisor");
 const process_1 = require("../../core/journal/process");
+const adapter_1 = require("../../core/journal/adapter");
 function currentBranch(cwd) {
     // stdio explicito (ver EXEC_STDIO en journal/process.ts): evita el relay
     // default de execFileSync del stderr de git hacia el stderr del llamante,
@@ -25,7 +26,7 @@ function registerWatchCommand(program) {
         .command('watch')
         .description('supervisor durable: ejecuta jobs, releva controladores caidos, nunca mata trabajo vivo')
         .option('--init', 'bootstrap: crea el journal de la rama actual, detecta verificadores y sale')
-        .option('--provider <p>', 'codex | claude-code', 'codex')
+        .option('--provider <p>', adapter_1.WATCH_PROVIDERS.join(' | '), 'codex')
         .option('--heartbeat-timeout <min>', 'minutos de silencio de heartbeat', '5')
         .option('--activity-window <min>', 'minutos extra sin actividad de proceso', '10')
         .action(async (opts) => {
@@ -36,6 +37,15 @@ function registerWatchCommand(program) {
             process.stdout.write(`journal inicializado para ${branch}; verificadores requeridos: ${JSON.stringify(out.requiredVerifiers)}\n`);
             return;
         }
+        // Validado ACA, antes de tocar nada: `adapterFor` ya rechazaba lo
+        // desconocido, pero recien en el primer tick — con el journal escrito y el
+        // lock tomado, y el error saliendo del supervisor en vez de del flag que lo
+        // causo. Un typo en `--provider` tiene que costar un mensaje, no un ciclo.
+        if (!(0, adapter_1.isWatchProvider)(opts.provider)) {
+            process.stderr.write(`--provider invalido: ${String(opts.provider)} (validos: ${adapter_1.WATCH_PROVIDERS.join(', ')})\n`);
+            process.exitCode = 1;
+            return;
+        }
         const cfg = {
             ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG,
             provider: opts.provider,

package/dist/src/core/artifact-name.js

@@ -0,0 +1,80 @@
+"use strict";
+// src/core/artifact-name.ts
+//
+// Modulo HOJA (sin imports de otros modulos del proyecto): validacion de los
+// nombres de artefacto que llegan desde CONTENIDO DE REGISTRY.
+//
+// Por que existe. Los nombres de `bundle.json` (`skills[]`, `workflows[]`,
+// `agents[]`) se usaban verbatim para construir rutas de instalacion:
+//
+//     path.join('~/.claude/skills', '../../.ssh/authorized_keys')
+//       => '~/.ssh/authorized_keys'
+//
+// y como `replaceArtifact` hace `fs.rmSync(targetPath, {recursive:true})` antes
+// de enlazar, un nombre como `../../.ssh` BORRABA recursivamente el ~/.ssh real
+// del usuario. Con `../../.config/autostart/x.desktop` se consigue ejecucion al
+// siguiente login. Confirmado end-to-end contra el binario real.
+//
+// El registry es contenido de terceros: un registry de equipo, uno interno, o
+// uno que alguien agrego con `awm registry add`. Todos los demas lectores de
+// contenido de registry de este repo (readRegistriesConfig, readRegistryManifest,
+// readProfile) ya rechazaban `..` y separadores — este camino era el unico sin
+// la guarda.
+//
+// Esta validacion es la PRIMERA de dos capas. La segunda es la asercion de
+// contencion en `physicalTarget` (install-planner.ts), que verifica que la ruta
+// resuelta caiga realmente dentro del directorio destino. Se mantienen las dos
+// a proposito: esta da un mensaje accionable que nombra el artefacto culpable;
+// aquella es el ancla estructural que atrapa cualquier camino futuro que
+// construya rutas sin pasar por aca.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeArtifactName = isSafeArtifactName;
+exports.assertSafeArtifactName = assertSafeArtifactName;
+/** Nombres reservados de Windows: no pueden ser un archivo ni un directorio.
+ *  Se rechazan en TODA plataforma a proposito — el registry es contenido
+ *  compartido, y un nombre que solo rompe en las maquinas Windows del equipo es
+ *  peor que uno rechazado de forma consistente en todas. */
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+/** ¿Es seguro usar este nombre como UN componente de ruta dentro del directorio
+ *  de instalacion? Sin `..`, sin separadores, sin rutas absolutas, sin bytes de
+ *  control, sin nombres reservados. */
+function isSafeArtifactName(name) {
+    if (typeof name !== 'string')
+        return false;
+    const value = name.trim();
+    if (value === '' || value !== name)
+        return false; // vacio, o con espacios al borde
+    // Windows recorta en silencio el punto/espacio final, asi que `evil.` y
+    // `evil` terminan en el MISMO archivo — un nombre que apunta a otro destino
+    // del que aparenta.
+    if (/[. ]$/.test(value))
+        return false;
+    // Bytes de control y NUL: truncan la ruta a nivel syscall en algunos SO.
+    // eslint-disable-next-line no-control-regex
+    if (/[\u0000-\u001f\u007f]/.test(value))
+        return false;
+    // Cualquier separador (de ambas plataformas) convierte esto en una ruta,
+    // no en un nombre. Idem `..`/`.` como componente completo.
+    if (value.includes('/') || value.includes('\\'))
+        return false;
+    if (value === '.' || value === '..')
+        return false;
+    // Absolutos de Windows (`C:\...`, `C:algo`) y de UNC ya quedan cubiertos por
+    // el chequeo de separador, pero un `C:` pelado no — y sigue siendo una
+    // referencia de unidad, no un nombre.
+    if (/^[a-zA-Z]:/.test(value))
+        return false;
+    if (WINDOWS_RESERVED.test(value))
+        return false;
+    return true;
+}
+/** Forma asertiva: lanza con un mensaje que nombra el tipo y el valor ofensivo,
+ *  para que el operador pueda ubicarlo en el `bundle.json` del registry. */
+function assertSafeArtifactName(name, type) {
+    if (!isSafeArtifactName(name)) {
+        throw new Error(`unsafe ${type} name from registry content: ${JSON.stringify(name)}. ` +
+            `Artifact names must be a single path component — no "..", no path separators, ` +
+            `no absolute paths, no control characters, and not a Windows reserved name.`);
+    }
+    return name;
+}

package/dist/src/core/bundle-install.js

@@ -10,6 +10,7 @@ exports.syncProfile = syncProfile;
 // src/core/bundle-install.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const artifact_name_1 = require("./artifact-name");
 const bundles_1 = require("./bundles");
 const providers_1 = require("../providers");
 const profile_1 = require("./profile");
@@ -18,14 +19,24 @@ const config_1 = require("../utils/config");
 const install_planner_1 = require("./install-planner");
 const install_transaction_1 = require("./install-transaction");
 function bundleArtifacts(b, contentDir) {
+    // Estos nombres vienen VERBATIM del `bundle.json` de un registry — contenido
+    // de terceros. Sin validar, `path.join(installDir, name)` con `../../.ssh`
+    // escapaba del directorio destino, y como el instalador hace
+    // `rmSync(target, {recursive:true})` antes de enlazar, eso BORRABA el ~/.ssh
+    // real del usuario. Se valida en el origen, donde el mensaje puede nombrar
+    // el artefacto culpable; `physicalTarget` ademas asegura contencion
+    // estructural sobre la ruta ya resuelta.
     const refs = [];
     for (const s of b.skills) {
+        (0, artifact_name_1.assertSafeArtifactName)(s.name, 'skill');
         refs.push({ name: s.name, type: 'skill', installName: s.name, sourcePath: path_1.default.join(contentDir, 'skills', s.name) });
     }
     for (const w of b.workflows) {
+        (0, artifact_name_1.assertSafeArtifactName)(w, 'workflow');
         refs.push({ name: w, type: 'workflow', installName: `${w}.md`, sourcePath: path_1.default.join(contentDir, 'workflows', `${w}.md`) });
     }
     for (const a of b.agents) {
+        (0, artifact_name_1.assertSafeArtifactName)(a, 'agent');
         refs.push({ name: a, type: 'agent', installName: `${a}.md`, sourcePath: path_1.default.join(contentDir, 'agents', `${a}.md`) });
     }
     return refs;
@@ -109,30 +120,62 @@ function addBundle(opts) {
  */
 function syncProfile(opts) {
     const profile = (0, profile_1.readProfile)(opts.projectRoot);
-    const installed = [];
     const skipped = [];
-    const modifiedFiles = [];
-    const transactionIds = [];
+    // ONE plan for the whole sync, not one per extension.
+    //
+    // This used to loop `installBundle` over `profile.extensions`, so N extensions
+    // meant N independent `applyInstallPlan` transactions. Each is atomic on its own;
+    // none is atomic with the others. A failure on the third extension left the first
+    // two committed and the tree in a state matching neither before nor after — and
+    // `awm sync` is the command a team runs to make a checkout match its profile, so
+    // "partially matches" is the one outcome it must not produce.
+    //
+    // Merging is safe because the two halves were already built for it: expanding a
+    // bundle (`expandBundleArtifacts`) is pure, and `planInstall` dedups by physical
+    // target across ALL the artifacts it is handed — which is also why two extensions
+    // sharing a dependency now collapse into one operation instead of racing to write
+    // the same path twice. `applyInstallPlan` backs up and rolls back per plan, so one
+    // plan is precisely what makes the sync atomic.
+    const intents = [];
     for (const ext of profile.extensions) {
-        if (!opts.bundles.some((b) => b.name === ext)) {
+        const bundle = opts.bundles.find((b) => b.name === ext);
+        if (!bundle) {
             skipped.push(`${ext} (bundle not found in registry — remove with \`awm remove ${ext}\`)`);
             continue;
         }
-        const summary = installBundle({
+        intents.push(...expandBundleArtifacts({
             bundleName: ext,
             bundles: opts.bundles,
             agents: opts.agents,
             method: opts.method,
             projectRoot: opts.projectRoot,
             contentDir: opts.contentDir,
-            applyPlan: opts.applyPlan,
-        });
-        installed.push(...summary.installed);
-        skipped.push(...summary.skipped);
-        modifiedFiles.push(...summary.modifiedFiles);
-        transactionIds.push(summary.transactionId);
+        }));
     }
     if (profile.extensions.length > 0)
         (0, profile_1.ensureSkillsGitignored)(opts.projectRoot, opts.agents);
-    return { installed, skipped, extensions: profile.extensions, transactionIds, modifiedFiles };
+    // Nothing resolvable: no plan, no transaction, nothing to name to `awm backup
+    // restore`. An empty `transactionIds` is the honest answer, not a phantom id.
+    if (intents.length === 0) {
+        return { installed: [], skipped, extensions: profile.extensions, transactionIds: [], modifiedFiles: [] };
+    }
+    const plan = (0, install_planner_1.planInstall)({
+        artifacts: intents,
+        selectedAgents: opts.agents,
+        enabledAgents: (0, config_1.getPreferences)().enabledAgents,
+        // Every extension in the profile is a project-scope bundle by construction
+        // (`shouldRecordExtension` only records those), so the whole sync resolves to
+        // one scope — which is what lets it be one plan.
+        scope: 'local',
+        projectRoot: opts.projectRoot,
+        method: opts.method,
+    });
+    const summary = (opts.applyPlan ?? install_transaction_1.applyInstallPlan)(plan);
+    return {
+        installed: summary.installed,
+        skipped: [...skipped, ...summary.skipped],
+        extensions: profile.extensions,
+        transactionIds: [summary.transactionId],
+        modifiedFiles: summary.modifiedFiles,
+    };
 }

package/dist/src/core/bundles.js

@@ -16,15 +16,59 @@ const registries_1 = require("./registries");
 function catalogPath(contentDir) {
     return path_1.default.join(contentDir, 'catalog.json');
 }
+/** Lee `catalog.json` de un registry.
+ *
+ *  El contenido de un registry es INPUT NO CONFIABLE (un registry de equipo,
+ *  interno, o agregado con `awm registry add`), asi que se valida forma antes de
+ *  desreferenciar. Sin esto, un solo archivo malformado en CUALQUIER registry
+ *  — incluido uno que llega por un `awm update` rutinario — hacia que `awm list`
+ *  y `awm add` murieran con un stack trace crudo de Node y ningun mensaje
+ *  accionable. Los demas lectores de contenido de registry de este repo
+ *  (readRegistriesConfig, readRegistryManifest, readProfile) ya validaban; estos
+ *  dos eran los que faltaban. */
 function readCatalog(contentDir) {
     const file = catalogPath(contentDir);
     if (!fs_1.default.existsSync(file))
         return [];
-    const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
-    return parsed.bundles ?? [];
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        throw new Error(`${file} is not valid JSON. Fix the file in its registry, then re-run \`awm update\`.`);
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        throw new Error(`${file} must contain a JSON object.`);
+    }
+    const bundles = parsed.bundles;
+    if (bundles === undefined)
+        return [];
+    if (!Array.isArray(bundles)) {
+        throw new Error(`${file}: "bundles" must be an array.`);
+    }
+    // Una entrada sin `source` usable haria que `path.join` tirara un
+    // TypeError opaco mas adelante; se descarta aca, nombrando el archivo.
+    return bundles.filter((entry) => entry !== null && typeof entry === 'object' && typeof entry.source === 'string');
 }
+/** Tolera `skills` ausente o mal formado: lo que no sea un array se trata como
+ *  vacio en vez de tirar `(raw ?? []).map is not a function`, y cada entrada se
+ *  valida individualmente. */
 function normalizeSkillRefs(raw) {
-    return (raw ?? []).map((s) => typeof s === 'string' ? { name: s, onSignal: false } : { name: s.name, onSignal: s.onSignal === true });
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((s) => {
+        if (typeof s === 'string')
+            return [{ name: s, onSignal: false }];
+        if (s !== null && typeof s === 'object' && typeof s.name === 'string') {
+            return [{ name: s.name, onSignal: s.onSignal === true }];
+        }
+        return [];
+    });
+}
+/** Array de strings, o vacio. Cualquier otra forma en el contenido del registry
+ *  se ignora en vez de propagarse hasta un crash aguas abajo. */
+function stringArray(raw) {
+    return Array.isArray(raw) ? raw.filter((v) => typeof v === 'string') : [];
 }
 function discoverBundles(contentDir) {
     const entries = readCatalog(contentDir);
@@ -33,17 +77,32 @@ function discoverBundles(contentDir) {
         const manifestPath = path_1.default.join(contentDir, entry.source, 'bundle.json');
         if (!fs_1.default.existsSync(manifestPath))
             continue;
-        const raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        let raw;
+        try {
+            raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch {
+            throw new Error(`${manifestPath} is not valid JSON. Fix the file in its registry, then re-run \`awm update\`.`);
+        }
+        if (raw === null || typeof raw !== 'object') {
+            throw new Error(`${manifestPath} must contain a JSON object.`);
+        }
+        const m = raw;
+        // Un bundle sin nombre usable no es instalable y solo produciria errores
+        // opacos mas adelante — se nombra el archivo y se falla aca.
+        if (typeof m.name !== 'string' || m.name === '') {
+            throw new Error(`${manifestPath}: "name" must be a non-empty string.`);
+        }
         bundles.push({
-            name: raw.name,
-            description: raw.description ?? '',
-            version: raw.version ?? '0.0.0',
-            scope: raw.scope ?? 'project',
-            visibility: raw.visibility ?? 'public',
-            dependsOn: raw.dependsOn ?? [],
-            skills: normalizeSkillRefs(raw.skills),
-            workflows: raw.workflows ?? [],
-            agents: raw.agents ?? [],
+            name: m.name,
+            description: typeof m.description === 'string' ? m.description : '',
+            version: typeof m.version === 'string' ? m.version : '0.0.0',
+            scope: m.scope ?? 'project',
+            visibility: m.visibility ?? 'public',
+            dependsOn: stringArray(m.dependsOn),
+            skills: normalizeSkillRefs(m.skills),
+            workflows: stringArray(m.workflows),
+            agents: stringArray(m.agents),
             contentRoot: contentDir,
         });
     }

package/dist/src/core/context/regenerate.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.regenerateGlobalContext = regenerateGlobalContext;
 // W3 — Regeneración del contexto global tras `awm update`.
-// Para cada agente con inyección config-instructions cuya config exista:
+// Para cada agente con un mecanismo de inyección aplicable:
 //   - 'stale'    (sentinel presente, archivo materializado ausente/viejo) → re-materializa.
 //   - 'injected' (ya fresco)                                              → no toca nada.
 //   - 'absent'   (sentinel ausente)                                       → no inyecta (eso es `awm init`).
@@ -21,10 +21,27 @@ function regenerateGlobalContext(targets = [...providers_1.AGENT_TARGETS], orch
     const out = [];
     for (const agent of targets) {
         const inj = (0, providers_1.providerFor)(agent).injection;
-        if (!inj || inj.type !== 'config-instructions')
-            continue;
-        if (!fs_1.default.existsSync(inj.configPath))
+        if (!inj)
             continue;
+        // Antes esto exigia `type === 'config-instructions'`, o sea que SOLO se
+        // regeneraba OpenCode: para codex, cursor y copilot (`managed-agents-md`)
+        // `awm update` era un no-op silencioso — ni un aviso — y el unico modo
+        // de refrescar su contexto era volver a correr `awm init`. Peor: doctor
+        // marcaba ⚠ pero seguia reportando `status: healthy` / exit 0, asi que
+        // un AGENTS.md desactualizado era invisible para cualquier gate de CI
+        // que mirara el codigo de salida.
+        //
+        // El destino global de `managed-agents-md` puede ser null (cursor y
+        // copilot no tienen archivo de contexto global); ahi no hay nada global
+        // que regenerar y se saltea limpio.
+        if (inj.type === 'config-instructions') {
+            if (!fs_1.default.existsSync(inj.configPath))
+                continue;
+        }
+        else if (inj.type === 'managed-agents-md') {
+            if (inj.globalPath === null)
+                continue;
+        }
         const op = {
             agent,
             scope: 'global',

package/dist/src/core/context/strategies/codex-agents.js

@@ -101,9 +101,25 @@ class CodexAgentsStrategy {
         // separate global file, so this is the only writer of the project AGENTS.md.
         const injection = provider.injection;
         const contextCoversThisFile = injection?.type === 'managed-agents-md' && injection.globalPath === null;
-        const result = contextCoversThisFile
+        // La guarda de arriba solo mira a ESTE provider. Pero el bloque es uno
+        // solo por archivo, y OTRO provider ya habilitado (cursor/copilot, cuyo
+        // contexto ES este archivo) pudo haberlo escrito antes — con el contexto
+        // AWM completo, del que PROJECT_GUIDANCE es apenas la cola. Sin este
+        // chequeo, un `awm init -a codex` posterior lo reemplazaba por las 6
+        // lineas de PROJECT_GUIDANCE: 140 -> 6, y para Copilot ese archivo es su
+        // UNICO canal de entrega, asi que se quedaba sin nada. Y al reves otra
+        // vez en el siguiente init. Se compara contra el bloque real en disco en
+        // vez de asumir quien escribio: si ya cubre PROJECT_GUIDANCE, lo que hay
+        // es un superconjunto y pisarlo seria perder informacion.
+        const agentsMdPath = path_1.default.join(projectRoot, 'AGENTS.md');
+        const existingBody = fs_1.default.existsSync(agentsMdPath)
+            ? (0, managed_block_1.managedBlockBody)(fs_1.default.readFileSync(agentsMdPath, 'utf-8'))
+            : null;
+        const alreadyCovered = existingBody !== null &&
+            (0, managed_block_1.normalizeManagedBody)(existingBody).includes((0, managed_block_1.normalizeManagedBody)(PROJECT_GUIDANCE));
+        const result = contextCoversThisFile || alreadyCovered
             ? 'unchanged'
-            : injectFile(path_1.default.join(projectRoot, 'AGENTS.md'), PROJECT_GUIDANCE);
+            : injectFile(agentsMdPath, PROJECT_GUIDANCE);
         let carrierResult = 'unchanged';
         if (agent === 'cursor') {
             // Cursor's Background/Cloud Agent does not reliably read AGENTS.md (open,

package/dist/src/core/diagnostics/checks.js

@@ -30,7 +30,15 @@ function machineChecks(m) {
             detail: `git ${m.registryCache.gitState ?? 'unknown'}`, remedy: none });
     }
     // machine.hook
-    if (m.hook.present && !m.hook.degraded) {
+    // Un provider sin mecanismo de hooks no puede "tener el hook instalado":
+    // no se emite fila alguna, igual que ya hacen el paso de init
+    // (init/steps.ts, "no hook mechanism for this agent") y el reporte por
+    // provider (provider-checks.ts, que descarta la fila). Emitir `missing`
+    // aca era lo que ponia `awm init` en exit 1 para 4 de los 6 providers.
+    if (!m.hook.applicable) {
+        // sin fila
+    }
+    else if (m.hook.present && !m.hook.degraded) {
         out.push({ id: 'machine.hook', level: 'machine', label: 'hook SessionStart', status: 'ok', remedy: none });
     }
     else if (m.hook.present) {
@@ -106,6 +114,17 @@ function projectChecks(p) {
         out.push({ id: 'project.activation', level: 'project', label: 'active bundles', status: 'missing',
             detail: `${missingLinks.length} missing, ${p.activeBundles.broken.length} broken`, remedy: cmd('awm sync') });
     }
+    // project.orphans — links colgantes que ya no pertenecen a ninguna extension.
+    // Fila propia y no parte de `project.activation`: ese check mide "falta lo que el
+    // profile pide", y esto es lo contrario — sobra lo que el profile ya no pide. Sin
+    // separarlos, un proyecto con todo lo esperado instalado reportaba `ok` mientras
+    // arrastraba skills muertas que el agente sigue intentando leer.
+    const orphans = p.orphanLinks.repairable.length + p.orphanLinks.dead.length;
+    if (orphans > 0) {
+        out.push({ id: 'project.orphans', level: 'project', label: 'orphaned skill links', status: 'warn',
+            detail: `${p.orphanLinks.repairable.length} repairable, ${p.orphanLinks.dead.length} dead`,
+            remedy: cmd('awm sync') });
+    }
     // project.sensors
     out.push(p.sensors.present
         ? { id: 'project.sensors', level: 'project', label: 'sensors', status: 'ok', remedy: none }
@@ -137,7 +156,12 @@ function projectChecks(p) {
 // actionable-but-expected transient states (rendered with ◷/⚠, not ✖) and
 // do not by themselves degrade `overall`, mirroring how a 'warn' CheckResult
 // doesn't degrade the machine+project report either.
-const DEGRADING_PROVIDER_STATES = ['missing', 'unsupported', 'broken', 'absent', 'conflict'];
+// `stale` cuenta como degradado: un contexto desactualizado es exactamente la
+// clase de problema que un gate de CI tiene que ver. Antes doctor imprimia ⚠
+// junto a `status: healthy` y exit 0, asi que un AGENTS.md viejo — o sobrescrito
+// por otro provider — era invisible para cualquier script que mirara el codigo
+// de salida. Un aviso que no cambia el veredicto no es un aviso, es ruido.
+const DEGRADING_PROVIDER_STATES = ['missing', 'unsupported', 'broken', 'absent', 'conflict', 'stale'];
 function computeProviderOverall(providers) {
     const degraded = providers.some((p) => p.checks.some((c) => DEGRADING_PROVIDER_STATES.includes(c.state)));
     return degraded ? 'degraded' : 'healthy';