agentic-workflow-manager 9.16.1 → 9.18.0

package/dist/src/core/environments/store.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentStoreError = void 0;
+exports.environmentsRoot = environmentsRoot;
+exports.envDir = envDir;
+exports.valuesPath = valuesPath;
+exports.getActiveEnvironmentName = getActiveEnvironmentName;
+exports.setActiveEnvironmentName = setActiveEnvironmentName;
+exports.readValues = readValues;
+exports.isInsideRegistryTree = isInsideRegistryTree;
+exports.assertNotInsideRegistryTree = assertNotInsideRegistryTree;
+exports.writeEnvValue = writeEnvValue;
+exports.writeFact = writeFact;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const atomic_file_1 = require("../atomic-file");
+const paths_1 = require("../paths");
+const registries_1 = require("../registries");
+class EnvironmentStoreError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EnvironmentStoreError';
+    }
+}
+exports.EnvironmentStoreError = EnvironmentStoreError;
+const DEFAULT_ENV_NAME = 'default';
+const META_FILE = 'meta.json';
+const VALUES_FILE = 'values.json';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Root of machine-local environment stores: `AWM_HOME/environments`. */
+function environmentsRoot() {
+    return path_1.default.join((0, paths_1.awmHome)(), 'environments');
+}
+function envDir(name) {
+    assertEnvName(name);
+    return path_1.default.join(environmentsRoot(), name);
+}
+function valuesPath(name) {
+    return path_1.default.join(envDir(name), VALUES_FILE);
+}
+function metaPath() {
+    return path_1.default.join(environmentsRoot(), META_FILE);
+}
+function assertEnvName(name) {
+    if (typeof name !== 'string' || name.trim() === '') {
+        throw new EnvironmentStoreError('environment name must be a non-empty string');
+    }
+    if (name.includes('\0')) {
+        throw new EnvironmentStoreError(`Invalid environment name ${JSON.stringify(name)}: NUL byte`);
+    }
+    const lower = name.toLowerCase();
+    if (lower === META_FILE.toLowerCase() || lower === VALUES_FILE.toLowerCase()) {
+        throw new EnvironmentStoreError(`Invalid environment name ${JSON.stringify(name)}: reserved store filename`);
+    }
+    if (name.includes('/') || name.includes('\\') || name.includes('..') || name === '.' || name === '..') {
+        throw new EnvironmentStoreError(`Invalid environment name ${JSON.stringify(name)}`);
+    }
+}
+function readMeta() {
+    const file = metaPath();
+    if (!fs_1.default.existsSync(file))
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch (e) {
+        throw new EnvironmentStoreError(`Invalid environments meta at ${file}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!isRecord(raw) || typeof raw.active !== 'string' || raw.active.trim() === '') {
+        throw new EnvironmentStoreError(`Invalid environments meta at ${file}: expected { active: string }`);
+    }
+    return { active: raw.active };
+}
+function writeMeta(meta) {
+    const file = metaPath();
+    assertNotInsideRegistryTree(file);
+    (0, atomic_file_1.writeFileAtomic)(file, JSON.stringify(meta, null, 2) + '\n');
+}
+/** Exactly one active environment per machine; default name `default` (RF-2.2). */
+function getActiveEnvironmentName() {
+    const meta = readMeta();
+    if (!meta)
+        return DEFAULT_ENV_NAME;
+    assertEnvName(meta.active);
+    return meta.active;
+}
+function setActiveEnvironmentName(name) {
+    assertEnvName(name);
+    writeMeta({ active: name });
+}
+function parseStoredEntry(id, raw) {
+    if (!isRecord(raw)) {
+        throw new EnvironmentStoreError(`values.${id} must be an object`);
+    }
+    if (typeof raw.value !== 'string') {
+        throw new EnvironmentStoreError(`values.${id}.value must be a string`);
+    }
+    if (raw.status !== 'fresh' && raw.status !== 'stale' && raw.status !== 'missing') {
+        throw new EnvironmentStoreError(`values.${id}.status must be fresh|stale|missing`);
+    }
+    if (typeof raw.updatedAt !== 'string') {
+        throw new EnvironmentStoreError(`values.${id}.updatedAt must be a string`);
+    }
+    const entry = {
+        value: raw.value,
+        status: raw.status,
+        updatedAt: raw.updatedAt,
+    };
+    if (raw.expiresAt !== undefined) {
+        if (typeof raw.expiresAt !== 'string') {
+            throw new EnvironmentStoreError(`values.${id}.expiresAt must be a string`);
+        }
+        entry.expiresAt = raw.expiresAt;
+    }
+    return entry;
+}
+function readValues(name) {
+    const file = valuesPath(name);
+    if (!fs_1.default.existsSync(file))
+        return {};
+    let raw;
+    try {
+        raw = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch (e) {
+        throw new EnvironmentStoreError(`Invalid values.json at ${file}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!isRecord(raw)) {
+        throw new EnvironmentStoreError(`values.json at ${file} must be a JSON object`);
+    }
+    const out = Object.create(null);
+    for (const [id, entry] of Object.entries(raw)) {
+        if (id === '__proto__' || id === 'constructor' || id === 'prototype') {
+            throw new EnvironmentStoreError(`values.json at ${file}: forbidden fact id ${JSON.stringify(id)}`);
+        }
+        out[id] = parseStoredEntry(id, entry);
+    }
+    return out;
+}
+/**
+ * Resolve a path through any intermediate symlinks (including when the leaf does
+ * not exist yet). Walks up to the nearest existing ancestor, realpaths it, then
+ * re-appends missing segments — same spirit as sensors/ledger realpath containment.
+ */
+function resolvePathForContainment(targetPath) {
+    const absolute = path_1.default.resolve(targetPath);
+    const missing = [];
+    let cursor = absolute;
+    while (!fs_1.default.existsSync(cursor)) {
+        const parent = path_1.default.dirname(cursor);
+        if (parent === cursor)
+            break;
+        missing.unshift(path_1.default.basename(cursor));
+        cursor = parent;
+    }
+    let realBase;
+    try {
+        realBase = fs_1.default.realpathSync.native(cursor);
+    }
+    catch {
+        realBase = cursor;
+    }
+    return missing.length === 0 ? realBase : path_1.default.join(realBase, ...missing);
+}
+function isPathInsideRoot(candidate, root) {
+    if ((0, paths_1.sameExistingPath)(candidate, root))
+        return true;
+    const rel = path_1.default.relative(root, candidate);
+    if (rel === '')
+        return true;
+    if (rel === '..')
+        return false;
+    if (!rel.startsWith(`..${path_1.default.sep}`) && !rel.startsWith('..') && !path_1.default.isAbsolute(rel))
+        return true;
+    const prefix = root.endsWith(path_1.default.sep) ? root : root + path_1.default.sep;
+    return candidate === root || candidate.startsWith(prefix);
+}
+/**
+ * True when `targetPath` (after resolving symlinks) is the same as or nested under
+ * any registry content root. Catches AWM_HOME/environments → registry symlink (RNF-1).
+ *
+ * Always unions `contentRoots()` with any explicit `registryRoots`. An empty
+ * explicit array no longer disables checks — callers that need extra roots pass
+ * them; they cannot opt out of installed content roots.
+ */
+function isInsideRegistryTree(targetPath, registryRoots) {
+    if (typeof targetPath !== 'string' || targetPath.trim() === '') {
+        throw new EnvironmentStoreError('target path must be a non-empty string');
+    }
+    const lexicalTarget = path_1.default.resolve(targetPath);
+    const realTarget = resolvePathForContainment(targetPath);
+    const roots = [...(0, registries_1.contentRoots)(), ...(registryRoots ?? [])];
+    for (const root of roots) {
+        if (typeof root !== 'string' || root.trim() === '')
+            continue;
+        const lexicalRoot = path_1.default.resolve(root);
+        const realRoot = resolvePathForContainment(root);
+        if (isPathInsideRoot(realTarget, realRoot))
+            return true;
+        // Also check lexical forms so non-existent trees still refuse obvious nesting.
+        if (isPathInsideRoot(lexicalTarget, lexicalRoot))
+            return true;
+    }
+    return false;
+}
+function assertNotInsideRegistryTree(targetPath, registryRoots) {
+    if (isInsideRegistryTree(targetPath, registryRoots)) {
+        throw new EnvironmentStoreError(`Refusing to write environment store inside a registry tree: ${targetPath} (RNF-1)`);
+    }
+}
+/**
+ * Atomic write of a values.json document. Refuses targets under registry roots (RNF-1).
+ */
+function writeEnvValue(targetPath, values, opts = {}) {
+    if (typeof targetPath !== 'string' || targetPath.trim() === '') {
+        throw new EnvironmentStoreError('target path must be a non-empty string');
+    }
+    if (!isRecord(values)) {
+        throw new EnvironmentStoreError('values must be an object');
+    }
+    for (const [id, entry] of Object.entries(values)) {
+        parseStoredEntry(id, entry);
+    }
+    // RNF-1: refuse registry-tree targets. Callers that need environmentsRoot placement
+    // (writeFact) pass valuesPath(name); this helper does not re-check environmentsRoot.
+    assertNotInsideRegistryTree(targetPath, opts.registryRoots);
+    (0, atomic_file_1.writeFileAtomic)(targetPath, JSON.stringify(values, null, 2) + '\n');
+}
+function validateValue(definition, value) {
+    if (definition.valueType === 'path') {
+        if (value.trim() === '') {
+            throw new EnvironmentStoreError('path value must be a non-empty string');
+        }
+    }
+    if (definition.valueType === 'enum') {
+        const allowed = definition.values ?? [];
+        if (!allowed.includes(value)) {
+            throw new EnvironmentStoreError(`enum value ${JSON.stringify(value)} is not one of: ${allowed.join(', ')}`);
+        }
+    }
+}
+function withExpiresAt(entry, definition) {
+    if (!definition || definition.durability !== 'volatile') {
+        return {
+            value: entry.value,
+            status: entry.status,
+            updatedAt: entry.updatedAt,
+        };
+    }
+    if (typeof definition.ttl !== 'number' || !Number.isFinite(definition.ttl) || definition.ttl <= 0) {
+        throw new EnvironmentStoreError('volatile fact definition requires a finite ttl > 0');
+    }
+    const ttlSeconds = definition.ttl;
+    const updatedMs = Date.parse(entry.updatedAt);
+    if (!Number.isFinite(updatedMs)) {
+        throw new EnvironmentStoreError(`updatedAt must be a valid ISO timestamp, got ${JSON.stringify(entry.updatedAt)}`);
+    }
+    let expiresAt;
+    try {
+        expiresAt = new Date(updatedMs + ttlSeconds * 1000).toISOString();
+    }
+    catch (e) {
+        if (e instanceof RangeError) {
+            throw new EnvironmentStoreError(`volatile expiresAt out of range for updatedAt=${JSON.stringify(entry.updatedAt)} ttl=${ttlSeconds}`);
+        }
+        throw e;
+    }
+    return { ...entry, expiresAt };
+}
+/**
+ * Write one fact into `environments/<name>/values.json` (RF-2.1). Atomic rename.
+ * When `catalog` is provided, unknown ids error and list `consultedRoots`.
+ */
+function writeFact(name, id, entry, opts = {}) {
+    assertEnvName(name);
+    if (typeof id !== 'string' || id.trim() === '') {
+        throw new EnvironmentStoreError('fact id must be a non-empty string');
+    }
+    if (!isRecord(entry) || typeof entry.value !== 'string') {
+        throw new EnvironmentStoreError('fact entry.value must be a string');
+    }
+    if (entry.status !== 'fresh' && entry.status !== 'stale' && entry.status !== 'missing') {
+        throw new EnvironmentStoreError('fact entry.status must be fresh|stale|missing');
+    }
+    if (typeof entry.updatedAt !== 'string') {
+        throw new EnvironmentStoreError('fact entry.updatedAt must be a string');
+    }
+    let definition = opts.definition;
+    if (opts.catalog) {
+        // Own keys only — prototype members (toString, …) are not catalog facts.
+        if (!Object.hasOwn(opts.catalog.facts, id)) {
+            const roots = opts.consultedRoots?.length
+                ? opts.consultedRoots.join(', ')
+                : '(no catalog roots)';
+            throw new EnvironmentStoreError(`Unknown fact id ${JSON.stringify(id)}; consulted: ${roots}`);
+        }
+        definition = definition ?? opts.catalog.facts[id];
+    }
+    if (definition) {
+        validateValue(definition, entry.value);
+    }
+    const nextEntry = withExpiresAt({
+        value: entry.value,
+        status: entry.status,
+        updatedAt: entry.updatedAt,
+        ...(entry.expiresAt !== undefined ? { expiresAt: entry.expiresAt } : {}),
+    }, definition);
+    const file = valuesPath(name);
+    assertNotInsideRegistryTree(file, opts.registryRoots);
+    const current = readValues(name);
+    const next = { ...current, [id]: nextEntry };
+    writeEnvValue(file, next, { registryRoots: opts.registryRoots });
+    // First write materializes the single active env as the env being written (RF-2.2).
+    if (!readMeta()) {
+        writeMeta({ active: name });
+    }
+}

package/dist/src/core/facts/catalog.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_VOLATILE_TTL_SECONDS = void 0;
+exports.parseFactsCatalog = parseFactsCatalog;
+const fs_1 = __importDefault(require("fs"));
+const registries_1 = require("../registries");
+const types_1 = require("./types");
+const VALUE_TYPES = ['string', 'path', 'enum'];
+const RESOLUTIONS = ['prompt'];
+const DURABILITIES = ['durable', 'volatile'];
+const INJECTS = ['reference', 'context'];
+/** Max volatile ttl (seconds) so updatedMs + ttl*1000 stays in a safe Date range. */
+exports.MAX_VOLATILE_TTL_SECONDS = 365 * 24 * 3600;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseFactEntry(id, raw) {
+    if (!types_1.FACT_ID_RE.test(id)) {
+        throw new types_1.FactsCatalogError(`Invalid fact id ${JSON.stringify(id)}: must match ${types_1.FACT_ID_RE}`);
+    }
+    if (!isRecord(raw)) {
+        throw new types_1.FactsCatalogError(`facts.${id} must be an object`);
+    }
+    if (typeof raw.valueType !== 'string' || !VALUE_TYPES.includes(raw.valueType)) {
+        throw new types_1.FactsCatalogError(`facts.${id}.valueType must be one of ${VALUE_TYPES.join(', ')}`);
+    }
+    const valueType = raw.valueType;
+    if (raw.resolution === 'command') {
+        throw new types_1.FactsCatalogError(`facts.${id}: resolution: command is not supported in v1 (use prompt / --value / editable store)`);
+    }
+    if (raw.resolution !== undefined) {
+        if (typeof raw.resolution !== 'string' || !RESOLUTIONS.includes(raw.resolution)) {
+            throw new types_1.FactsCatalogError(`facts.${id}.resolution must be "prompt" in v1`);
+        }
+    }
+    if (raw.durability !== undefined) {
+        if (typeof raw.durability !== 'string' || !DURABILITIES.includes(raw.durability)) {
+            throw new types_1.FactsCatalogError(`facts.${id}.durability must be durable|volatile`);
+        }
+    }
+    if (raw.inject !== undefined) {
+        if (typeof raw.inject !== 'string' || !INJECTS.includes(raw.inject)) {
+            throw new types_1.FactsCatalogError(`facts.${id}.inject must be reference|context`);
+        }
+    }
+    const def = {
+        valueType,
+        resolution: raw.resolution ?? 'prompt',
+        durability: raw.durability ?? 'durable',
+        inject: raw.inject ?? 'reference',
+    };
+    if (raw.description !== undefined) {
+        if (typeof raw.description !== 'string') {
+            throw new types_1.FactsCatalogError(`facts.${id}.description must be a string`);
+        }
+        def.description = raw.description;
+    }
+    if (valueType === 'enum') {
+        if (!Array.isArray(raw.values) || raw.values.length === 0 || raw.values.some((v) => typeof v !== 'string')) {
+            throw new types_1.FactsCatalogError(`facts.${id}.values must be a non-empty string array when valueType is enum`);
+        }
+        def.values = raw.values;
+    }
+    else if (raw.values !== undefined) {
+        throw new types_1.FactsCatalogError(`facts.${id}.values is only allowed when valueType is enum`);
+    }
+    if (raw.ttl !== undefined) {
+        if (typeof raw.ttl !== 'number' || !Number.isFinite(raw.ttl) || raw.ttl < 0) {
+            throw new types_1.FactsCatalogError(`facts.${id}.ttl must be a non-negative number`);
+        }
+        def.ttl = raw.ttl;
+    }
+    if (def.durability === 'volatile') {
+        if (typeof def.ttl !== 'number' ||
+            !Number.isFinite(def.ttl) ||
+            def.ttl <= 0 ||
+            def.ttl > exports.MAX_VOLATILE_TTL_SECONDS) {
+            throw new types_1.FactsCatalogError(`facts.${id}: durability volatile requires finite ttl in (0, ${exports.MAX_VOLATILE_TTL_SECONDS}] seconds`);
+        }
+    }
+    return def;
+}
+function parseObject(raw) {
+    if (!isRecord(raw)) {
+        throw new types_1.FactsCatalogError('facts catalog must be a JSON object');
+    }
+    if (raw.schemaVersion !== 1) {
+        throw new types_1.FactsCatalogError(`facts catalog schemaVersion must be 1, got ${JSON.stringify(raw.schemaVersion)}`);
+    }
+    if (!isRecord(raw.facts)) {
+        throw new types_1.FactsCatalogError('facts catalog must include a facts object');
+    }
+    const facts = {};
+    for (const [id, entry] of Object.entries(raw.facts)) {
+        if (id === '') {
+            throw new types_1.FactsCatalogError('fact id must be non-empty');
+        }
+        facts[id] = parseFactEntry(id, entry);
+    }
+    return { schemaVersion: 1, facts };
+}
+/**
+ * Parse a facts catalog from an in-memory object or from a file path string.
+ * Named errors: {@link FactsCatalogError}.
+ */
+function parseFactsCatalog(rawOrPath) {
+    if (typeof rawOrPath === 'string') {
+        try {
+            if (!(0, registries_1.assertRegularRegistryFile)(rawOrPath)) {
+                throw new types_1.FactsCatalogError(`facts catalog not found at ${rawOrPath}`);
+            }
+        }
+        catch (e) {
+            if (e instanceof types_1.FactsCatalogError)
+                throw e;
+            throw new types_1.FactsCatalogError(e instanceof Error ? e.message : `Cannot inspect facts catalog at ${rawOrPath}: ${String(e)}`);
+        }
+        let text;
+        try {
+            text = fs_1.default.readFileSync(rawOrPath, 'utf-8');
+        }
+        catch (e) {
+            throw new types_1.FactsCatalogError(`Cannot read facts catalog at ${rawOrPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch (e) {
+            throw new types_1.FactsCatalogError(`Invalid JSON in facts catalog at ${rawOrPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return parseObject(parsed);
+    }
+    return parseObject(rawOrPath);
+}

package/dist/src/core/facts/needs.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSkillNeeds = readSkillNeeds;
+exports.findOrphanNeeds = findOrphanNeeds;
+const fs_1 = __importDefault(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const frontmatter_1 = require("../frontmatter");
+const types_1 = require("./types");
+/**
+ * Read the `needs` list from a skill SKILL.md frontmatter.
+ * Absent → `[]`. Invalid shape → {@link SkillNeedsError}.
+ */
+function readSkillNeeds(skillMdPath) {
+    let raw;
+    try {
+        const stat = fs_1.default.lstatSync(skillMdPath);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new types_1.SkillNeedsError(`Skill path ${skillMdPath} must be a regular file`);
+        }
+        raw = fs_1.default.readFileSync(skillMdPath, 'utf-8');
+    }
+    catch (e) {
+        if (e instanceof types_1.SkillNeedsError)
+            throw e;
+        throw new types_1.SkillNeedsError(`Cannot read skill at ${skillMdPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const block = (0, frontmatter_1.matchFrontmatterBlock)(raw);
+    if (block === null)
+        return [];
+    let parsed;
+    try {
+        parsed = js_yaml_1.default.load(block);
+    }
+    catch (e) {
+        throw new types_1.SkillNeedsError(`Invalid skill frontmatter at ${skillMdPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (parsed === null || parsed === undefined)
+        return [];
+    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new types_1.SkillNeedsError(`Invalid skill frontmatter at ${skillMdPath}: expected a mapping`);
+    }
+    const needs = parsed.needs;
+    if (needs === undefined)
+        return [];
+    if (!Array.isArray(needs) || needs.some((n) => typeof n !== 'string' || n === '')) {
+        throw new types_1.SkillNeedsError(`Invalid needs at ${skillMdPath}: needs must be a YAML list of non-empty strings`);
+    }
+    return needs;
+}
+/** Ids in `needs` that are absent from the catalog (fail-closed; never invent). */
+function findOrphanNeeds(needs, catalog) {
+    // Own keys only — `in` would treat Object.prototype (toString, …) as catalog facts.
+    return needs.filter((id) => !Object.hasOwn(catalog.facts, id));
+}

package/dist/src/core/facts/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillNeedsError = exports.FactsCatalogError = exports.FACT_ID_RE = exports.FACTS_MIN_CLI_VERSION = void 0;
+/** First CLI version that understands registry facts / needs. Bump only with intentional release. */
+exports.FACTS_MIN_CLI_VERSION = '9.18.0';
+/** Dotted fact ids: `repos.root`, `aws.profile.dev`. */
+exports.FACT_ID_RE = /^[a-z][a-z0-9]*(\.[a-z0-9]+)+$/;
+class FactsCatalogError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FactsCatalogError';
+    }
+}
+exports.FactsCatalogError = FactsCatalogError;
+class SkillNeedsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SkillNeedsError';
+    }
+}
+exports.SkillNeedsError = SkillNeedsError;

package/dist/src/core/init/steps.js

@@ -75,7 +75,11 @@ exports.defaultActions = {
             throw new Error('sensor init does not migrate an existing v2 manifest; run awm sensors bootstrap');
         if (plan.kind === 'create')
             (0, bootstrap_1.applySensorBootstrap)(plan);
-        const pack = plan.kind === 'create' && plan.manifest.mode === 'project-sensors' ? plan.manifest.pack : (0, detection_1.detectStack)(o.cwd).pack;
+        const detected = (0, detection_1.detectStack)(o.cwd).pack;
+        const declared = plan.kind === 'create' && plan.manifest.mode === 'project-sensors' ? plan.manifest.pack : undefined;
+        const pack = typeof declared === 'string' && declared.length > 0 ? declared : detected;
+        if (typeof pack !== 'string' || pack.length === 0)
+            throw new Error('sensor init could not resolve a pack id');
         return { detection: { pack }, manifest: { pack } };
     },
     addExtension: (root, name) => { (0, profile_1.addExtension)(root, name); },

package/dist/src/index.js

@@ -37,6 +37,7 @@ const doctor_1 = require("./commands/doctor");
 const backup_1 = require("./commands/backup");
 const init_1 = require("./commands/init");
 const registry_1 = require("./commands/registry");
+const env_1 = require("./commands/env");
 const pin_1 = require("./commands/pin");
 const export_1 = require("./commands/export");
 const agent_1 = require("./commands/agent");
@@ -743,6 +744,7 @@ miroCmd.command('sync <storyMapPath>')
 (0, backup_1.registerBackupCommand)(exports.program);
 (0, init_1.registerInitCommand)(exports.program);
 (0, registry_1.registerRegistryCommand)(exports.program);
+(0, env_1.registerEnvCommand)(exports.program);
 (0, pin_1.registerPinCommands)(exports.program);
 (0, export_1.registerExportCommand)(exports.program);
 (0, agent_1.registerAgentCommand)(exports.program);