agentic-workflow-manager 9.16.1 → 9.18.0

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

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFactDefinitions = mergeFactDefinitions;
+exports.registerEnvCommand = registerEnvCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const catalog_1 = require("../../core/facts/catalog");
+const registries_1 = require("../../core/registries");
+const store_1 = require("../../core/environments/store");
+const resolve_1 = require("../../core/environments/resolve");
+/**
+ * Merge facts catalogs from installed registry roots.
+ * Later roots may refine a fact, but must not weaken durability: volatile wins
+ * over durable so an expired secret cannot be revived by a durable override.
+ */
+function mergeFactDefinitions(into, from) {
+    for (const [id, next] of Object.entries(from)) {
+        const prev = Object.hasOwn(into, id) ? into[id] : undefined;
+        if (!prev) {
+            into[id] = next;
+            continue;
+        }
+        if (prev.durability === 'volatile' && next.durability === 'durable') {
+            const kept = { ...next, durability: 'volatile' };
+            if (prev.ttl !== undefined)
+                kept.ttl = prev.ttl;
+            into[id] = kept;
+            continue;
+        }
+        into[id] = next;
+    }
+}
+function loadCatalogFromInstalledRoots() {
+    const merged = { schemaVersion: 1, facts: {} };
+    for (const root of (0, registries_1.contentRoots)()) {
+        const factsPath = path_1.default.join(root, 'facts.json');
+        if (!fs_1.default.existsSync(factsPath))
+            continue;
+        const catalog = (0, catalog_1.parseFactsCatalog)(factsPath);
+        mergeFactDefinitions(merged.facts, catalog.facts);
+    }
+    return merged;
+}
+function defaultConsultedRoots() {
+    return (0, registries_1.contentRoots)();
+}
+function requireValue(value, flagHint) {
+    if (value === undefined) {
+        throw new store_1.EnvironmentStoreError(`${flagHint} requires --value <text> in non-interactive mode (prompt / editable store / --value only; RF-3.3)`);
+    }
+    return value;
+}
+async function defaultPromptValue(question) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await new Promise((resolve) => {
+            rl.question(question, (answer) => resolve(answer));
+        });
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveValue(optsValue, flagHint, factId, deps) {
+    if (optsValue !== undefined)
+        return optsValue;
+    if (!deps.stdinIsTTY()) {
+        return requireValue(undefined, flagHint);
+    }
+    return Promise.resolve(deps.promptValue(`Value for ${factId}: `));
+}
+function setFact(factId, rawValue, deps) {
+    const catalog = deps.loadCatalog();
+    const name = (0, store_1.getActiveEnvironmentName)();
+    (0, store_1.writeFact)(name, factId, {
+        value: rawValue,
+        status: 'fresh',
+        updatedAt: new Date().toISOString(),
+    }, {
+        catalog,
+        consultedRoots: deps.consultedRoots(),
+    });
+}
+function registerEnvCommand(program, deps = {}) {
+    const loadCatalog = deps.loadCatalog ?? loadCatalogFromInstalledRoots;
+    const consultedRoots = deps.consultedRoots ?? defaultConsultedRoots;
+    const now = deps.now ?? (() => new Date());
+    const stdinIsTTY = deps.stdinIsTTY ?? (() => Boolean(process.stdin.isTTY));
+    const promptValue = deps.promptValue ?? defaultPromptValue;
+    const env = program.command('env').description('manage machine-local operator environments (facts store)');
+    env.command('status')
+        .description('show active environment and fact statuses vs catalog')
+        .action(() => {
+        const name = (0, store_1.getActiveEnvironmentName)();
+        const catalog = loadCatalog();
+        const store = (0, store_1.readValues)(name);
+        const statuses = (0, resolve_1.statusFor)(catalog, store, now());
+        const lines = [
+            `Active environment: ${name}`,
+            `Store: ${(0, store_1.valuesPath)(name)}`,
+            '',
+            'Facts:',
+        ];
+        const ids = Object.keys(catalog.facts).sort();
+        if (ids.length === 0) {
+            lines.push('  (no facts in consulted catalogs)');
+        }
+        else {
+            for (const id of ids) {
+                lines.push(`  ${id}: ${statuses[id]}`);
+            }
+        }
+        process.stdout.write(lines.join('\n') + '\n');
+    });
+    env.command('set <factId>')
+        .description('set a fact value in the active environment (--value for non-interactive)')
+        .option('--value <text>', 'fact value (required non-interactive; never runs registry commands)')
+        .action(async (factId, opts) => {
+        const value = await resolveValue(opts.value, 'awm env set', factId, {
+            stdinIsTTY,
+            promptValue,
+        });
+        setFact(factId, value, { loadCatalog, consultedRoots });
+        process.stdout.write(`Set ${factId} in environment ${(0, store_1.getActiveEnvironmentName)()}\n`);
+    });
+    env.command('edit')
+        .description('print the absolute path of the active environment values.json')
+        .action(() => {
+        const name = (0, store_1.getActiveEnvironmentName)();
+        const file = (0, store_1.valuesPath)(name);
+        process.stdout.write(`${file}\n`);
+    });
+    env.command('refresh [factId]')
+        .description('re-set a fact value (prompt / --value only; no registry commands)')
+        .option('--value <text>', 'new value (required non-interactive)')
+        .option('--all', 'refresh every fact present in the store (interactive prompts, or pass factId)')
+        .action(async (factId, opts) => {
+        if (opts.all && !factId) {
+            if (!stdinIsTTY()) {
+                throw new store_1.EnvironmentStoreError('awm env refresh --all requires a TTY (or pass <factId> with --value in non-interactive mode)');
+            }
+            const name = (0, store_1.getActiveEnvironmentName)();
+            const ids = Object.keys((0, store_1.readValues)(name));
+            if (ids.length === 0) {
+                throw new store_1.EnvironmentStoreError('awm env refresh --all: active store has no facts');
+            }
+            for (const id of ids) {
+                const value = await Promise.resolve(promptValue(`Value for ${id}: `));
+                setFact(id, value, { loadCatalog, consultedRoots });
+                process.stdout.write(`Refreshed ${id} in environment ${(0, store_1.getActiveEnvironmentName)()}\n`);
+            }
+            return;
+        }
+        if (!factId) {
+            throw new store_1.EnvironmentStoreError('awm env refresh requires <factId> (or interactive --all)');
+        }
+        const value = await resolveValue(opts.value, 'awm env refresh', factId, {
+            stdinIsTTY,
+            promptValue,
+        });
+        setFact(factId, value, { loadCatalog, consultedRoots });
+        process.stdout.write(`Refreshed ${factId} in environment ${(0, store_1.getActiveEnvironmentName)()}\n`);
+    });
+    env.command('use <name>')
+        .description('switch the active environment (one active per machine)')
+        .action((name) => {
+        (0, store_1.setActiveEnvironmentName)(name);
+        process.stdout.write(`Active environment: ${name}\n`);
+    });
+    env.command('inject')
+        .description('print JSON injection payload for the active environment (default mode: reference)')
+        .option('--mode <mode>', 'injection mode: reference|context', 'reference')
+        .action((opts) => {
+        const rawMode = opts.mode ?? 'reference';
+        const mode = rawMode === 'reference' || rawMode === 'context' ? rawMode : 'reference';
+        const name = (0, store_1.getActiveEnvironmentName)();
+        const catalog = loadCatalog();
+        const store = (0, store_1.readValues)(name);
+        const result = (0, resolve_1.buildInjection)({
+            catalog,
+            store,
+            storePath: (0, store_1.valuesPath)(name),
+            inject: mode,
+            now: now(),
+        });
+        process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    });
+}

package/dist/src/commands/preflight/checks.js

@@ -100,13 +100,18 @@ function checkContextKernel(cwd) {
         remedy: inspection.remedy,
     };
 }
+function isDisabledCheckDetail(detail) {
+    return detail === 'disabled' || detail.startsWith('disabled ');
+}
 function manifestView(status) {
-    if (!status.pack)
+    // Only-project READY has pack null but non-empty checks — still a valid view (RF-2.8).
+    // Do not invent a fake pack id; keep pack null and surface sensors from status.checks.
+    if (status.mode !== 'project-sensors' && status.mode !== 'legacy-v1')
         return null;
     const sensors = Object.fromEntries(Object.entries(status.checks).map(([name, check]) => [name, {
-            enabled: check.detail !== 'disabled',
+            enabled: !isDisabledCheckDetail(check.detail),
         }]));
-    return { pack: status.pack, sensors };
+    return { pack: status.pack ?? null, sensors };
 }
 /**
  * Total sensor entries and how many are enabled (`enabled !== false`, so a missing
@@ -139,12 +144,32 @@ function checkManifest(status) {
         };
     }
     if (status.mode === 'invalid') {
+        if (status.reason === 'schema-unsupported') {
+            return {
+                id: 'manifest',
+                ok: false,
+                detail: '.awm/sensors.json uses an unsupported schema',
+                remedy: 'fix or regenerate it with `awm sensors init`',
+            };
+        }
+        // JSON.parse succeeded but schema/entry validation failed (RF-4.1/4.2).
+        // Never claim "not valid JSON"; name the sensor/field from status.reason.
+        if (typeof status.reason === 'string' && (status.reason.startsWith('schema-invalid') || status.reason.includes('Invalid sensor manifest'))) {
+            const detail = status.reason.startsWith('schema-invalid:')
+                ? status.reason.slice('schema-invalid:'.length).trim()
+                : status.reason;
+            // RF-3.3: project schema invalidity must not lead with `awm sensors init`.
+            return {
+                id: 'manifest',
+                ok: false,
+                detail,
+                remedy: 'repair the invalid sensor entry in .awm/sensors.json',
+            };
+        }
         return {
             id: 'manifest',
             ok: false,
-            detail: status.reason === 'schema-unsupported'
-                ? '.awm/sensors.json uses an unsupported schema'
-                : '.awm/sensors.json is not valid JSON',
+            detail: '.awm/sensors.json is not valid JSON',
             remedy: 'fix or regenerate it with `awm sensors init`',
         };
     }
@@ -165,6 +190,14 @@ function checkManifest(status) {
     // for the detected stack, so `awm sensors init` built an honest, empty manifest
     // rather than inventing defaults. That must not read as "all sensors disabled".
     if (total === 0) {
+        if (manifest.pack === null) {
+            return {
+                id: 'manifest',
+                ok: false,
+                detail: 'only-project manifest has no sensors',
+                remedy: 'add source:"project" sensor entries to .awm/sensors.json, or declare a pack',
+            };
+        }
         return {
             id: 'manifest',
             ok: false,
@@ -179,12 +212,14 @@ function checkManifest(status) {
     // gap is one missing tool could then configure sensors and still never pass.
     const uninitialized = Object.keys(status.uninitialized ?? {});
     const gap = uninitialized.length === 0 ? '' : `; ${uninitialized.length} applicable sensor(s) not initialized: ${uninitialized.join(', ')}`;
-    return {
-        id: 'manifest',
-        ok: true,
-        detail: (enabled === 0 ? `pack ${manifest.pack}, all ${total} sensors disabled (deliberate opt-out)`
-            : `pack ${manifest.pack}, ${enabled}/${total} sensors enabled`) + gap,
-    };
+    const summary = manifest.pack === null
+        ? (enabled === 0
+            ? `only-project, all ${total} sensors disabled (deliberate opt-out)`
+            : `only-project, ${enabled}/${total} project-declared sensors enabled`)
+        : (enabled === 0
+            ? `pack ${manifest.pack}, all ${total} sensors disabled (deliberate opt-out)`
+            : `pack ${manifest.pack}, ${enabled}/${total} sensors enabled`);
+    return { id: 'manifest', ok: true, detail: summary + gap };
 }
 /** Every enabled sensor's command must resolve. This is the check nothing was calling. */
 async function checkTools(cwd, status) {
@@ -198,11 +233,14 @@ async function checkTools(cwd, status) {
     // already guards against; this defends the invariant independently rather than
     // relying solely on `checkManifest`'s gate to catch this exact manifest shape.
     if (Object.keys(status.checks).length === 0) {
+        const packId = typeof status.pack === 'string' && status.pack.length > 0 ? status.pack : null;
         return {
             id: 'tools',
             ok: false,
             detail: 'no sensors configured to check (0 sensor entries in the manifest)',
-            remedy: `registry has no pack for '${status.pack}': run \`awm update\` or add a registry that has it`,
+            remedy: packId === null
+                ? 'add source:"project" sensor entries to .awm/sensors.json, or declare a pack'
+                : `registry has no pack for '${packId}': run \`awm update\` or add a registry that has it`,
         };
     }
     const broken = Object.entries(status.checks).filter(([, c]) => !c.ok);
@@ -227,6 +265,9 @@ function checkPack(cwd, status) {
     const manifest = manifestView(status);
     if (!manifest)
         return { id: 'pack', ok: true, detail: 'skipped (no manifest)' };
+    if (manifest.pack === null) {
+        return { id: 'pack', ok: true, detail: 'no pack (project-declared sensors only)' };
+    }
     const detection = (0, detection_1.detectStack)(cwd);
     if (manifest.pack === 'generic' && detection.pack !== 'generic') {
         return {
@@ -327,6 +368,15 @@ async function checkSensorExecution(cwd) {
     try {
         const output = await (0, run_1.runSensors)({ cwd, all: true });
         if (output.overall === 'pass') {
+            const invalid = output.invalidEntries ?? [];
+            if (invalid.length > 0) {
+                return {
+                    id: 'sensors-execution',
+                    ok: false,
+                    detail: `sensors passed but ${invalid.length} invalidEntries remain: ${invalid.map(entry => `${entry.name} (${entry.reason})`).join('; ')}`,
+                    remedy: 'repair the invalid sensor entries in .awm/sensors.json, then rerun `awm preflight --verify-sensors`',
+                };
+            }
             return { id: 'sensors-execution', ok: true, detail: 'all selected sensors completed with pass' };
         }
         return {