agentic-workflow-manager 9.4.1 → 9.6.0

package/dist/src/commands/sensors/compatibility/materialize.js

@@ -3,18 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializePortableSensors = materializePortableSensors;
 exports.materializeResolvedSensors = materializeResolvedSensors;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const manifest_1 = require("./manifest");
 const contract_1 = require("./contract");
+const safe_file_1 = require("./safe-file");
+const native_bridge_1 = require("../../../core/secure-fs/native-bridge");
+const MAX_ASSET_BYTES = 1024 * 1024;
 function stableId(value, label) {
     if (typeof value !== 'string' || !/^[a-z][a-z0-9-]*$/.test(value))
         throw new Error(`${label} must be a stable lowercase id`);
     return value;
 }
 function containedAsset(value, label) {
-    if (typeof value !== 'string' || value.length === 0 || value.includes('\\') || path_1.default.isAbsolute(value) || value.split('/').some(part => !part || part === '.' || part === '..'))
+    if (typeof value !== 'string' || value.length === 0 || value.includes('\\') || path_1.default.isAbsolute(value) || /^(?:[A-Za-z]:|[\\/])/.test(value) || value.split('/').some(part => !part || part === '.' || part === '..'))
         throw new Error(`${label} must be a contained relative asset path`);
     return value;
 }
@@ -31,45 +35,266 @@ function root(value, label) {
     }
     return resolved;
 }
-function atomicWrite(destination, content) {
-    const directory = path_1.default.dirname(destination);
-    fs_1.default.mkdirSync(directory, { recursive: true });
-    const temporary = path_1.default.join(directory, `.${path_1.default.basename(destination)}.${process.pid}.${Date.now()}.tmp`);
+/** Resolve a monorepo package only when it is a real directory below the project.
+ * A lexical `foo/bar` is not enough: a symlink must never turn an asset write
+ * into an authority outside the project transaction. */
+function containedPackageRoot(projectRoot, packageRoot) {
+    const candidate = path_1.default.join(projectRoot, packageRoot);
+    let stat;
     try {
-        fs_1.default.writeFileSync(temporary, content, { encoding: 'utf8', flag: 'wx' });
-        fs_1.default.renameSync(temporary, destination);
+        stat = fs_1.default.lstatSync(candidate);
     }
-    finally {
+    catch {
+        throw new Error('packageRoot must be an existing contained directory');
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error('packageRoot must be a non-symbolic contained directory');
+    const realProject = fs_1.default.realpathSync(projectRoot);
+    const realPackage = fs_1.default.realpathSync(candidate);
+    const relative = path_1.default.relative(realProject, realPackage);
+    if (relative === '' || relative === '..' || relative.startsWith(`..${path_1.default.sep}`) || path_1.default.isAbsolute(relative)) {
+        throw new Error('packageRoot must be a contained directory');
+    }
+    return realPackage;
+}
+function registryPackRoot(value) {
+    const resolved = root(value, 'packRoot');
+    const parsed = path_1.default.parse(resolved);
+    let current = parsed.root;
+    for (const component of path_1.default.relative(parsed.root, resolved).split(path_1.default.sep).filter(Boolean)) {
+        let stat;
         try {
-            if (fs_1.default.existsSync(temporary))
-                fs_1.default.unlinkSync(temporary);
+            stat = fs_1.default.lstatSync(current);
+        }
+        catch {
+            throw new Error('packRoot must be an existing directory');
         }
-        catch { /* best effort cleanup */ }
+        if (stat.isSymbolicLink())
+            throw new Error('packRoot contains a symlink');
+        current = path_1.default.join(current, component);
+    }
+    let stat;
+    try {
+        stat = fs_1.default.lstatSync(current);
+    }
+    catch {
+        throw new Error('packRoot must be an existing directory');
+    }
+    if (stat.isSymbolicLink())
+        throw new Error('packRoot contains a symlink');
+    return resolved;
+}
+function atomicWrite(configRoot, asset, content, noClobber = false) {
+    const destination = path_1.default.join(configRoot, ...asset.split('/'));
+    if (noClobber) {
+        (0, safe_file_1.writeProjectFile)(configRoot, asset, Buffer.from(content, 'utf8'), { mode: 'create', createParents: true });
+        return;
+    }
+    let expected;
+    try {
+        expected = (0, safe_file_1.readInspectedBoundedFileWithIdentity)(destination, fs_1.default.lstatSync(destination, { bigint: true }), MAX_ASSET_BYTES, () => new Error(`project destination cannot be safely read: ${asset}`));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    (0, safe_file_1.writeProjectFile)(configRoot, asset, Buffer.from(content, 'utf8'), expected
+        ? { mode: 'replace', expected: expected.content, expectedIdentity: expected.identity, createParents: false }
+        : { mode: 'create', createParents: true });
+}
+/** Publish a new asset without ever replacing an owner-created destination. */
+function atomicCreateAsset(configRoot, asset, content) {
+    try {
+        (0, safe_file_1.writeProjectFile)(configRoot, asset, Buffer.from(content, 'utf8'), { mode: 'create', createParents: true });
+    }
+    catch (error) {
+        if (error.message === `project destination rejected by secure-fs: ${native_bridge_1.PROJECT_DESTINATION_ALREADY_EXISTS_MESSAGE}`)
+            return false;
+        throw error;
+    }
+    return true;
+}
+function selectedRegistryAsset(packRoot, asset) {
+    let current = packRoot;
+    for (const [index, component] of asset.split('/').entries()) {
+        let stat;
+        try {
+            stat = fs_1.default.lstatSync(current, { bigint: true });
+        }
+        catch {
+            throw new Error(`selected asset is missing from pack: ${asset}`);
+        }
+        if (stat.isSymbolicLink())
+            throw new Error(`selected asset contains a symlink: ${asset}`);
+        if (index < asset.split('/').length - 1 && !stat.isDirectory())
+            throw new Error(`selected asset is missing from pack: ${asset}`);
+        current = path_1.default.join(current, component);
+    }
+    let stat;
+    try {
+        stat = fs_1.default.lstatSync(current, { bigint: true });
+    }
+    catch {
+        throw new Error(`selected asset is missing from pack: ${asset}`);
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error(`selected asset must be a regular file: ${asset}`);
+    if (stat.size > BigInt(MAX_ASSET_BYTES))
+        throw new Error(`selected asset exceeds the 1 MiB limit: ${asset}`);
+    return { file: current, stat };
+}
+function readSelectedRegistryAsset(packRoot, selected, asset) {
+    // Re-walk the bounded parent chain immediately before the leaf-safe-open.
+    // A replaced ancestor can otherwise redirect the same pathname outside the
+    // inspected registry between selection and the O_NOFOLLOW leaf open.
+    const current = selectedRegistryAsset(packRoot, asset);
+    if (current.stat.dev !== selected.stat.dev || current.stat.ino !== selected.stat.ino) {
+        throw new Error(`selected asset changed identity during safe open: ${asset}`);
+    }
+    const failure = (reason) => {
+        if (reason === 'open')
+            return new Error(`selected asset cannot be safely opened: ${asset}`);
+        if (reason === 'regular')
+            return new Error(`selected asset must be a regular file: ${asset}`);
+        if (reason === 'identity')
+            return new Error(`selected asset changed identity during safe open: ${asset}`);
+        if (reason === 'size')
+            return new Error(`selected asset changed size during safe open: ${asset}`);
+        return new Error(`selected asset exceeds the 1 MiB limit: ${asset}`);
+    };
+    return (0, safe_file_1.readInspectedBoundedFile)(selected.file, selected.stat, MAX_ASSET_BYTES, failure).toString('utf8');
+}
+function portableSource(source, pack) {
+    if (!source || typeof source !== 'object')
+        throw new Error('portable source is required');
+    const candidate = source;
+    if (!candidate.registry || typeof candidate.registry !== 'object' || typeof candidate.registry.name !== 'string' || typeof candidate.registry.contentRoot !== 'string' || typeof candidate.path !== 'string') {
+        throw new Error('portable source must be a validated pack source');
+    }
+    const registry = stableId(candidate.registry.name, 'source.registry.name');
+    const configuredRoot = root(candidate.registry.contentRoot, 'source.registry.contentRoot');
+    let contentRoot;
+    try {
+        contentRoot = fs_1.default.realpathSync(configuredRoot);
     }
+    catch {
+        throw new Error('source.registry.contentRoot must be canonicalizable');
+    }
+    const packRoot = registryPackRoot(path_1.default.join(contentRoot, 'sensor-packs', pack));
+    const expectedPack = path_1.default.join(packRoot, 'pack.json');
+    if (path_1.default.resolve(candidate.path) !== expectedPack)
+        throw new Error('portable source selected pack path does not match its registry');
+    const inspectedPack = selectedRegistryAsset(packRoot, 'pack.json');
+    if (readSelectedRegistryAsset(packRoot, inspectedPack, 'pack.json') !== candidate.content) {
+        throw new Error('portable source changed after bootstrap planning');
+    }
+    return { registry, packRoot };
 }
 function priorAssets(projectRoot) {
     const manifest = path_1.default.join(projectRoot, '.awm', 'sensors.json');
-    if (!fs_1.default.existsSync(manifest))
-        return [];
+    let stat;
+    try {
+        stat = fs_1.default.lstatSync(manifest, { bigint: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw new Error(`cannot materialize over invalid sensor manifest ${manifest}`);
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error(`cannot materialize over invalid sensor manifest ${manifest}`);
     let parsed;
     try {
-        parsed = JSON.parse(fs_1.default.readFileSync(manifest, 'utf8'));
+        parsed = JSON.parse((0, safe_file_1.readInspectedBoundedFile)(manifest, stat, MAX_ASSET_BYTES, () => new Error(`cannot materialize over invalid sensor manifest ${manifest}`)).toString('utf8'));
     }
     catch {
         throw new Error(`cannot materialize over invalid sensor manifest ${manifest}`);
     }
     const parsedManifest = (0, manifest_1.parseSensorManifest)(parsed, manifest);
-    if (parsedManifest.kind !== 'v2')
-        return [];
-    return Object.values(parsedManifest.pack.sensors).flatMap(sensor => sensor.assets ?? []);
+    if (parsedManifest.kind === 'v2')
+        return Object.values(parsedManifest.pack.sensors).flatMap(sensor => sensor.assets ?? []);
+    if (parsedManifest.kind === 'v3' && parsedManifest.pack.mode === 'project-sensors')
+        return Object.values(parsedManifest.pack.sensors).flatMap(sensor => sensor.assets ?? []);
+    return [];
+}
+/** Materialize a previously selected logical registry source into a portable v3 manifest. */
+function materializePortableSensors(input) {
+    if (!input || typeof input !== 'object')
+        throw new Error('materialization input is required');
+    const projectRoot = root(input.projectRoot, 'projectRoot');
+    const pack = stableId(input.pack, 'pack');
+    const source = portableSource(input.source, pack);
+    const packRoot = source.packRoot;
+    if (!input.sensors || typeof input.sensors !== 'object' || Array.isArray(input.sensors))
+        throw new Error('sensors must be an object');
+    const candidate = {
+        schemaVersion: 3, mode: 'project-sensors', pack,
+        ...(input.packSelection === 'explicit' ? { packSelection: 'explicit' } : {}),
+        source: { registry: source.registry },
+        ...(input.packageRoot ? { packageRoot: containedAsset(input.packageRoot, 'packageRoot') } : {}),
+        sensors: input.sensors,
+    };
+    const parsed = (0, manifest_1.parseSensorManifest)(candidate, 'portable materialized manifest');
+    if (parsed.kind !== 'v3' || parsed.pack.mode !== 'project-sensors')
+        throw new Error('portable materialized manifest must be v3 project-sensors');
+    const manifest = parsed.pack;
+    for (const [name, sensor] of Object.entries(manifest.sensors)) {
+        if (sensor.policyRef)
+            (0, contract_1.resolveSemgrepPolicy)(sensor.policyRef, path_1.default.join(packRoot, 'pack.json'), `sensors.${name}`);
+    }
+    const selected = [...new Set(Object.values(manifest.sensors).flatMap(sensor => sensor.assets ?? []))].map((asset, index) => containedAsset(asset, `assets[${index}]`)).sort();
+    // Establish every registry authority and read every selected byte before the
+    // first project mutation. A bad later asset must not strand an earlier one.
+    const publications = input.configure === false ? [] : selected.map(asset => {
+        const selectedSource = selectedRegistryAsset(packRoot, asset);
+        return { asset, content: readSelectedRegistryAsset(packRoot, selectedSource, asset) };
+    });
+    return (0, safe_file_1.withProjectLease)(projectRoot, () => {
+        const configRoot = manifest.packageRoot ? containedPackageRoot(projectRoot, manifest.packageRoot) : projectRoot;
+        const prior = priorAssets(projectRoot);
+        const configured = [];
+        const preserved = [];
+        const created = [];
+        try {
+            if (input.configure !== false) {
+                for (const publication of publications) {
+                    if (atomicCreateAsset(configRoot, publication.asset, publication.content)) {
+                        const destination = manifest.packageRoot ? `${manifest.packageRoot}/${publication.asset}` : publication.asset;
+                        const absolute = path_1.default.join(projectRoot, ...destination.split('/'));
+                        const stat = fs_1.default.lstatSync(absolute, { bigint: true });
+                        const observed = (0, safe_file_1.readInspectedBoundedFileWithIdentity)(absolute, stat, MAX_ASSET_BYTES, () => new Error(`created asset cannot be safely observed: ${publication.asset}`));
+                        if (!observed.content.equals(Buffer.from(publication.content, 'utf8'))) {
+                            throw new Error(`created asset changed before manifest publication: ${publication.asset}`);
+                        }
+                        created.push({ destination, identity: observed.identity });
+                        configured.push(publication.asset);
+                    }
+                    else
+                        preserved.push(publication.asset);
+                }
+            }
+            atomicWrite(projectRoot, '.awm/sensors.json', (0, manifest_1.serializeManifestV3)(manifest), true);
+        }
+        catch (error) {
+            for (const entry of created.reverse()) {
+                try {
+                    (0, safe_file_1.removeObservedProjectFile)(projectRoot, entry.destination, entry.identity);
+                }
+                catch { /* Preserve a competing replacement; report the original publication failure. */ }
+            }
+            throw error;
+        }
+        return { manifest, configured, preserved, orphaned: prior.filter(asset => !selected.includes(asset)).sort() };
+    });
 }
 /** Write a selected, v2-only sensor configuration without overwriting user files.
- * The manifest is the commit point: created assets are removed best-effort if writing it fails. */
+ * Assets published before a manifest failure are deliberately left in place: a
+ * pathname rollback cannot be made safe after a concurrent project-parent swap. */
 function materializeResolvedSensors(input) {
     if (!input || typeof input !== 'object')
         throw new Error('materialization input is required');
     const projectRoot = root(input.projectRoot, 'projectRoot');
-    const packRoot = root(input.packRoot, 'packRoot');
+    const packRoot = registryPackRoot(input.packRoot);
     const pack = stableId(input.pack, 'pack');
     if (!input.sensors || typeof input.sensors !== 'object' || Array.isArray(input.sensors))
         throw new Error('sensors must be an object');
@@ -86,7 +311,6 @@ function materializeResolvedSensors(input) {
     // Assets land where sensors will actually run — projectRoot by default, or
     // packageRoot underneath it for a monorepo. The manifest write below stays
     // pinned to projectRoot either way (see atomicWrite call at the end).
-    const configRoot = manifest.packageRoot ? root(path_1.default.join(projectRoot, manifest.packageRoot), 'packageRoot') : projectRoot;
     // A policy reference is deliberately not a materialized asset. Resolve it here
     // from the registry-owned sibling only, so a manifest cannot turn arbitrary
     // registry content into a project write through a cosmetic policy field.
@@ -95,44 +319,22 @@ function materializeResolvedSensors(input) {
             (0, contract_1.resolveSemgrepPolicy)(sensor.policyRef, path_1.default.join(packRoot, 'pack.json'), `sensors.${name}`);
     }
     const selected = [...new Set(Object.values(sensors).flatMap(sensor => sensor.assets ?? []))].map((asset, index) => containedAsset(asset, `assets[${index}]`)).sort();
-    const prior = priorAssets(projectRoot);
-    const configured = [];
-    const preserved = [];
-    const created = [];
-    try {
+    return (0, safe_file_1.withProjectLease)(projectRoot, () => {
+        const configRoot = manifest.packageRoot ? root(path_1.default.join(projectRoot, manifest.packageRoot), 'packageRoot') : projectRoot;
+        const prior = priorAssets(projectRoot);
+        const configured = [];
+        const preserved = [];
         if (input.configure !== false) {
             for (const asset of selected) {
-                const source = path_1.default.join(packRoot, ...asset.split('/'));
-                const destination = path_1.default.join(configRoot, ...asset.split('/'));
-                let stat;
-                try {
-                    stat = fs_1.default.lstatSync(source);
-                }
-                catch {
-                    throw new Error(`selected asset is missing from pack: ${asset}`);
+                const selectedSource = selectedRegistryAsset(packRoot, asset);
+                if (atomicCreateAsset(configRoot, asset, readSelectedRegistryAsset(packRoot, selectedSource, asset))) {
+                    configured.push(asset);
                 }
-                if (!stat.isFile() || stat.isSymbolicLink())
-                    throw new Error(`selected asset must be a regular file: ${asset}`);
-                if (fs_1.default.existsSync(destination)) {
+                else
                     preserved.push(asset);
-                    continue;
-                }
-                fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
-                atomicWrite(destination, fs_1.default.readFileSync(source, 'utf8'));
-                created.push(destination);
-                configured.push(asset);
             }
         }
-        atomicWrite(path_1.default.join(projectRoot, '.awm', 'sensors.json'), (0, manifest_1.serializeManifestV2)(manifest));
-    }
-    catch (error) {
-        for (const file of created.reverse()) {
-            try {
-                fs_1.default.unlinkSync(file);
-            }
-            catch { /* best effort transaction rollback */ }
-        }
-        throw error;
-    }
-    return { manifest, configured, preserved, orphaned: prior.filter(asset => !selected.includes(asset)).sort() };
+        atomicWrite(projectRoot, '.awm/sensors.json', (0, manifest_1.serializeManifestV2)(manifest));
+        return { manifest, configured, preserved, orphaned: prior.filter(asset => !selected.includes(asset)).sort() };
+    });
 }

package/dist/src/commands/sensors/compatibility/pack-source.js

@@ -3,11 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPackSources = listPackSources;
 exports.resolvePackSource = resolvePackSource;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const registries_1 = require("../../../core/registries");
+const safe_file_1 = require("./safe-file");
 const MAX_PACK_BYTES = 1024 * 1024;
+const MAX_DIAGNOSTIC_IDENTITY_LENGTH = 128;
+function diagnosticRegistryName(name) {
+    return name.length <= MAX_DIAGNOSTIC_IDENTITY_LENGTH
+        ? name
+        : `${name.slice(0, MAX_DIAGNOSTIC_IDENTITY_LENGTH - 3)}...`;
+}
 function validPackName(pack) {
     return typeof pack === 'string' && /^[a-z][a-z0-9-]*$/.test(pack);
 }
@@ -17,50 +25,79 @@ function contained(root, candidate) {
 }
 /** Walk each component under contentRoot with lstat: realpath alone would hide an
  * internal symlink whose target happens to remain inside the registry. */
-function inspectContainedPack(root, pack) {
+function inspectContainedPack(root, pack, registryName) {
+    let rootStat;
+    try {
+        rootStat = fs_1.default.lstatSync(root, { bigint: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new Error(`registry "${registryName}" pack source root cannot be inspected`);
+    }
+    if (rootStat.isSymbolicLink())
+        throw new Error(`registry "${registryName}" pack source root must not be a symbolic link`);
+    if (!rootStat.isDirectory())
+        throw new Error(`registry "${registryName}" pack source root must be a regular directory`);
     const components = ['sensor-packs', pack, 'pack.json'];
     let candidate = root;
     for (let index = 0; index < components.length; index++) {
         candidate = path_1.default.join(candidate, components[index]);
         let stat;
         try {
-            stat = fs_1.default.lstatSync(candidate);
+            stat = fs_1.default.lstatSync(candidate, { bigint: true });
         }
         catch (error) {
             if (error.code === 'ENOENT')
                 return undefined;
             if (error.code === 'ENOTDIR')
-                throw new Error(`pack source ${candidate} has a non-regular or symbolic parent`);
-            throw new Error(`cannot inspect pack source ${candidate}`);
+                throw new Error(`registry "${registryName}" pack source has a non-regular or symbolic parent`);
+            throw new Error(`registry "${registryName}" pack source cannot be inspected`);
         }
         if (stat.isSymbolicLink())
-            throw new Error(`pack source ${candidate} must not contain symbolic links`);
+            throw new Error(`registry "${registryName}" pack source must not contain symbolic links`);
         if (index < components.length - 1 && !stat.isDirectory())
-            throw new Error(`pack source ${candidate} has a non-regular parent`);
+            throw new Error(`registry "${registryName}" pack source has a non-regular parent`);
         if (index === components.length - 1)
             return { candidate, stat };
     }
     throw new Error('pack source component walk did not reach pack.json');
 }
+function readContainedPack(real, inspected, registryName) {
+    const failure = (reason) => {
+        if (reason === 'open')
+            return new Error(`registry "${registryName}" pack source cannot be safely opened`);
+        if (reason === 'regular')
+            return new Error(`registry "${registryName}" pack source must be a contained regular file, never a symbolic link`);
+        if (reason === 'identity')
+            return new Error(`registry "${registryName}" pack source changed identity during safe open`);
+        if (reason === 'size')
+            return new Error(`registry "${registryName}" pack source changed size during safe open`);
+        return new Error(`registry "${registryName}" pack source exceeds the 1 MiB limit`);
+    };
+    return (0, safe_file_1.readInspectedBoundedFile)(real, inspected, MAX_PACK_BYTES, failure).toString('utf8');
+}
 /** Resolve only an exact, regular pack.json beneath the first configured registry.
  * Registry order is authority; an unsafe claimed source is a hard failure, not a fallback. */
-function resolvePackSource(pack, options = {}) {
+function listPackSources(pack, options = {}) {
     if (!validPackName(pack))
         throw new Error('pack name must be a stable lowercase id');
     const registries = options.registries ?? (0, registries_1.listRegistries)();
     if (!Array.isArray(registries))
         throw new Error('registries must be an array');
+    const sources = [];
     for (const registry of registries) {
-        if (!registry || typeof registry.contentRoot !== 'string' || registry.contentRoot.trim() === '')
-            throw new Error('registry has an invalid content root');
-        const inspected = inspectContainedPack(registry.contentRoot, pack);
+        if (!registry || typeof registry.name !== 'string' || !/^[a-z][a-z0-9-]*$/.test(registry.name) || typeof registry.contentRoot !== 'string' || registry.contentRoot.trim() === '')
+            throw new Error('registry has an invalid identity or content root');
+        const registryName = diagnosticRegistryName(registry.name);
+        const inspected = inspectContainedPack(registry.contentRoot, pack, registryName);
         if (!inspected)
             continue;
         const { candidate, stat } = inspected;
         if (!stat.isFile())
-            throw new Error(`pack source ${candidate} must be a contained regular file, never a symbolic link`);
-        if (stat.size > MAX_PACK_BYTES)
-            throw new Error(`pack source ${candidate} exceeds the 1 MiB limit`);
+            throw new Error(`registry "${registryName}" pack source must be a contained regular file, never a symbolic link`);
+        if (stat.size > BigInt(MAX_PACK_BYTES))
+            throw new Error(`registry "${registryName}" pack source exceeds the 1 MiB limit`);
         let root;
         let real;
         try {
@@ -68,11 +105,18 @@ function resolvePackSource(pack, options = {}) {
             real = fs_1.default.realpathSync(candidate);
         }
         catch {
-            throw new Error(`cannot canonicalize pack source ${candidate}`);
+            throw new Error(`registry "${registryName}" pack source cannot be canonicalized`);
         }
         if (!contained(root, real))
-            throw new Error(`pack source ${candidate} escapes its registry root`);
-        return { path: real, content: fs_1.default.readFileSync(real, 'utf8'), registry };
+            throw new Error(`registry "${registryName}" pack source escapes its registry root`);
+        const content = readContainedPack(real, stat, registryName);
+        sources.push({ path: real, content, registry });
     }
-    throw new Error(`sensor pack "${pack}" was not found in configured registries`);
+    return sources;
+}
+function resolvePackSource(pack, options = {}) {
+    const source = listPackSources(pack, options)[0];
+    if (source)
+        return source;
+    throw new Error('sensor pack was not found in configured registries');
 }