@dexto/agent-management 1.5.7 → 1.6.0

package/dist/images/image-store.cjs

@@ -0,0 +1,256 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var image_store_exports = {};
+__export(image_store_exports, {
+  getDefaultImageStoreDir: () => getDefaultImageStoreDir,
+  getImagePackageInstallDir: () => getImagePackageInstallDir,
+  getImagePackagesDir: () => getImagePackagesDir,
+  getImageRegistryPath: () => getImageRegistryPath,
+  isFileLikeImageSpecifier: () => isFileLikeImageSpecifier,
+  loadImageRegistry: () => loadImageRegistry,
+  parseImageSpecifier: () => parseImageSpecifier,
+  removeImageFromStore: () => removeImageFromStore,
+  resolveFileLikeImageSpecifierToFileUrl: () => resolveFileLikeImageSpecifierToFileUrl,
+  resolveFileLikeImageSpecifierToPath: () => resolveFileLikeImageSpecifierToPath,
+  resolveImageEntryFileFromStore: () => resolveImageEntryFileFromStore,
+  saveImageRegistry: () => saveImageRegistry,
+  setActiveImageVersion: () => setActiveImageVersion
+});
+module.exports = __toCommonJS(image_store_exports);
+var import_path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_os = require("os");
+var import_url = require("url");
+var import_zod = require("zod");
+var import_path2 = require("../utils/path.js");
+const ImageRegistryFileSchema = import_zod.z.object({
+  version: import_zod.z.literal(1),
+  images: import_zod.z.record(
+    import_zod.z.object({
+      active: import_zod.z.string().optional(),
+      installed: import_zod.z.record(
+        import_zod.z.object({
+          entryFile: import_zod.z.string(),
+          installedAt: import_zod.z.string()
+        }).strict()
+      )
+    }).strict()
+  )
+}).strict();
+function getDefaultImageStoreDir() {
+  const override = process.env.DEXTO_IMAGE_STORE_DIR?.trim();
+  if (override) {
+    return override;
+  }
+  return (0, import_path2.getDextoGlobalPath)("images");
+}
+function getImageRegistryPath(storeDir = getDefaultImageStoreDir()) {
+  return import_path.default.join(storeDir, "registry.json");
+}
+function getImagePackagesDir(storeDir = getDefaultImageStoreDir()) {
+  return import_path.default.join(storeDir, "packages");
+}
+function getImagePackageInstallDir(imageId, version, storeDir = getDefaultImageStoreDir()) {
+  const packagesDir = getImagePackagesDir(storeDir);
+  const parts = imageId.startsWith("@") ? imageId.split("/") : [imageId];
+  return import_path.default.join(packagesDir, ...parts, version);
+}
+function loadImageRegistry(storeDir = getDefaultImageStoreDir()) {
+  const registryPath = getImageRegistryPath(storeDir);
+  if (!(0, import_fs.existsSync)(registryPath)) {
+    return { version: 1, images: {} };
+  }
+  try {
+    const raw = JSON.parse((0, import_fs.readFileSync)(registryPath, "utf-8"));
+    const parsed = ImageRegistryFileSchema.safeParse(raw);
+    if (!parsed.success) {
+      return { version: 1, images: {} };
+    }
+    return parsed.data;
+  } catch {
+    return { version: 1, images: {} };
+  }
+}
+async function saveImageRegistry(data, storeDir = getDefaultImageStoreDir()) {
+  const registryPath = getImageRegistryPath(storeDir);
+  await import_fs2.promises.mkdir(import_path.default.dirname(registryPath), { recursive: true });
+  const tempPath = `${registryPath}.tmp.${Date.now()}`;
+  try {
+    await import_fs2.promises.writeFile(tempPath, JSON.stringify(data, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await import_fs2.promises.rename(tempPath, registryPath);
+  } catch (error) {
+    await import_fs2.promises.rm(tempPath, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+}
+function parseImageSpecifier(specifier) {
+  const trimmed = specifier.trim();
+  if (!trimmed) {
+    throw new Error("Image specifier cannot be empty");
+  }
+  if (trimmed.startsWith("@")) {
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex === -1) {
+      return { id: trimmed };
+    }
+    const versionIndex2 = trimmed.indexOf("@", slashIndex + 1);
+    if (versionIndex2 === -1) {
+      return { id: trimmed };
+    }
+    const version = trimmed.slice(versionIndex2 + 1).trim();
+    return {
+      id: trimmed.slice(0, versionIndex2),
+      ...version.length > 0 ? { version } : {}
+    };
+  }
+  const versionIndex = trimmed.lastIndexOf("@");
+  if (versionIndex > 0) {
+    const version = trimmed.slice(versionIndex + 1).trim();
+    return {
+      id: trimmed.slice(0, versionIndex),
+      ...version.length > 0 ? { version } : {}
+    };
+  }
+  return { id: trimmed };
+}
+function isFileLikeImageSpecifier(specifier) {
+  if (specifier === "." || specifier === "..") return true;
+  if (specifier.startsWith("file://")) return true;
+  if (specifier.startsWith("~/")) return true;
+  if (specifier.startsWith("./") || specifier.startsWith("../")) return true;
+  if (import_path.default.isAbsolute(specifier)) return true;
+  if (/^[a-zA-Z]:[\\/]/.test(specifier)) return true;
+  return false;
+}
+function resolveFileLikeImageSpecifierToPath(specifier, cwd = process.cwd()) {
+  if (specifier.startsWith("file://")) {
+    return (0, import_url.fileURLToPath)(specifier);
+  }
+  if (specifier.startsWith("~/")) {
+    return import_path.default.join((0, import_os.homedir)(), specifier.slice(2));
+  }
+  if (import_path.default.isAbsolute(specifier)) {
+    return specifier;
+  }
+  return import_path.default.resolve(cwd, specifier);
+}
+function resolveFileLikeImageSpecifierToFileUrl(specifier, cwd = process.cwd()) {
+  if (specifier.startsWith("file://")) {
+    return specifier;
+  }
+  const filePath = resolveFileLikeImageSpecifierToPath(specifier, cwd);
+  return (0, import_url.pathToFileURL)(filePath).href;
+}
+async function resolveImageEntryFileFromStore(specifier, storeDir = getDefaultImageStoreDir()) {
+  const registry = loadImageRegistry(storeDir);
+  const entry = registry.images[specifier.id];
+  if (!entry) {
+    return null;
+  }
+  const installedVersions = Object.keys(entry.installed);
+  if (installedVersions.length === 0) {
+    return null;
+  }
+  const resolvedVersion = specifier.version ?? entry.active;
+  if (!resolvedVersion) {
+    if (installedVersions.length === 1) {
+      return entry.installed[installedVersions[0] ?? ""]?.entryFile ?? null;
+    }
+    throw new Error(
+      `Image '${specifier.id}' has multiple installed versions but no active version set. Run: dexto image use ${specifier.id}@<version>`
+    );
+  }
+  const resolved = entry.installed[resolvedVersion];
+  if (!resolved) {
+    throw new Error(
+      `Image '${specifier.id}@${resolvedVersion}' is not installed. Run: dexto image install ${specifier.id}@${resolvedVersion}`
+    );
+  }
+  return resolved.entryFile;
+}
+async function setActiveImageVersion(imageId, version, storeDir = getDefaultImageStoreDir()) {
+  const registry = loadImageRegistry(storeDir);
+  const entry = registry.images[imageId];
+  if (!entry || !entry.installed[version]) {
+    throw new Error(`Image '${imageId}@${version}' is not installed`);
+  }
+  entry.active = version;
+  await saveImageRegistry(registry, storeDir);
+}
+async function removeImageFromStore(imageId, options = {}) {
+  const storeDir = options.storeDir ?? getDefaultImageStoreDir();
+  const version = options.version;
+  const registry = loadImageRegistry(storeDir);
+  const entry = registry.images[imageId];
+  if (!entry) {
+    return;
+  }
+  if (version) {
+    delete entry.installed[version];
+    if (entry.active === version) {
+      delete entry.active;
+    }
+    const installDir = getImagePackageInstallDir(imageId, version, storeDir);
+    await import_fs2.promises.rm(installDir, { recursive: true, force: true }).catch(() => {
+    });
+    if (Object.keys(entry.installed).length === 0) {
+      delete registry.images[imageId];
+    }
+  } else {
+    const versions = Object.keys(entry.installed);
+    for (const v of versions) {
+      const installDir = getImagePackageInstallDir(imageId, v, storeDir);
+      await import_fs2.promises.rm(installDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    delete registry.images[imageId];
+  }
+  await saveImageRegistry(registry, storeDir);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultImageStoreDir,
+  getImagePackageInstallDir,
+  getImagePackagesDir,
+  getImageRegistryPath,
+  isFileLikeImageSpecifier,
+  loadImageRegistry,
+  parseImageSpecifier,
+  removeImageFromStore,
+  resolveFileLikeImageSpecifierToFileUrl,
+  resolveFileLikeImageSpecifierToPath,
+  resolveImageEntryFileFromStore,
+  saveImageRegistry,
+  setActiveImageVersion
+});

package/dist/images/image-store.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+declare const ImageRegistryFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    images: z.ZodRecord<z.ZodString, z.ZodObject<{
+        active: z.ZodOptional<z.ZodString>;
+        installed: z.ZodRecord<z.ZodString, z.ZodObject<{
+            entryFile: z.ZodString;
+            installedAt: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            installedAt: string;
+            entryFile: string;
+        }, {
+            installedAt: string;
+            entryFile: string;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        installed: Record<string, {
+            installedAt: string;
+            entryFile: string;
+        }>;
+        active?: string | undefined;
+    }, {
+        installed: Record<string, {
+            installedAt: string;
+            entryFile: string;
+        }>;
+        active?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    version: 1;
+    images: Record<string, {
+        installed: Record<string, {
+            installedAt: string;
+            entryFile: string;
+        }>;
+        active?: string | undefined;
+    }>;
+}, {
+    version: 1;
+    images: Record<string, {
+        installed: Record<string, {
+            installedAt: string;
+            entryFile: string;
+        }>;
+        active?: string | undefined;
+    }>;
+}>;
+export type ImageRegistryFile = z.output<typeof ImageRegistryFileSchema>;
+export interface ImageSpecifierParts {
+    id: string;
+    version?: string;
+}
+export declare function getDefaultImageStoreDir(): string;
+export declare function getImageRegistryPath(storeDir?: string): string;
+export declare function getImagePackagesDir(storeDir?: string): string;
+export declare function getImagePackageInstallDir(imageId: string, version: string, storeDir?: string): string;
+export declare function loadImageRegistry(storeDir?: string): ImageRegistryFile;
+export declare function saveImageRegistry(data: ImageRegistryFile, storeDir?: string): Promise<void>;
+export declare function parseImageSpecifier(specifier: string): ImageSpecifierParts;
+export declare function isFileLikeImageSpecifier(specifier: string): boolean;
+export declare function resolveFileLikeImageSpecifierToPath(specifier: string, cwd?: string): string;
+export declare function resolveFileLikeImageSpecifierToFileUrl(specifier: string, cwd?: string): string;
+export declare function resolveImageEntryFileFromStore(specifier: ImageSpecifierParts, storeDir?: string): Promise<string | null>;
+export declare function setActiveImageVersion(imageId: string, version: string, storeDir?: string): Promise<void>;
+export declare function removeImageFromStore(imageId: string, options?: {
+    version?: string;
+    storeDir?: string;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=image-store.d.ts.map

package/dist/images/image-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-store.d.ts","sourceRoot":"","sources":["../../src/images/image-store.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBhB,CAAC;AAEd,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE,MAAM,WAAW,mBAAmB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAMhD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,GAAE,MAAkC,GAAG,MAAM,CAEzF;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,MAAkC,GAAG,MAAM,CAExF;AAED,wBAAgB,yBAAyB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAkC,GAC7C,MAAM,CAIR;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,GAAE,MAAkC,GAAG,iBAAiB,CAgBjG;AAED,wBAAsB,iBAAiB,CACnC,IAAI,EAAE,iBAAiB,EACvB,QAAQ,GAAE,MAAkC,GAC7C,OAAO,CAAC,IAAI,CAAC,CAef;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,CAkC1E;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAQnE;AAED,wBAAgB,mCAAmC,CAC/C,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAsB,GAC5B,MAAM,CAcR;AAED,wBAAgB,sCAAsC,CAClD,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAsB,GAC5B,MAAM,CAOR;AAED,wBAAsB,8BAA8B,CAChD,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,GAAE,MAAkC,GAC7C,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8BxB;AAED,wBAAsB,qBAAqB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAkC,GAC7C,OAAO,CAAC,IAAI,CAAC,CASf;AAED,wBAAsB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GACtD,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/dist/images/image-store.js

@@ -0,0 +1,210 @@
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { fileURLToPath, pathToFileURL } from "url";
+import { z } from "zod";
+import { getDextoGlobalPath } from "../utils/path.js";
+const ImageRegistryFileSchema = z.object({
+  version: z.literal(1),
+  images: z.record(
+    z.object({
+      active: z.string().optional(),
+      installed: z.record(
+        z.object({
+          entryFile: z.string(),
+          installedAt: z.string()
+        }).strict()
+      )
+    }).strict()
+  )
+}).strict();
+function getDefaultImageStoreDir() {
+  const override = process.env.DEXTO_IMAGE_STORE_DIR?.trim();
+  if (override) {
+    return override;
+  }
+  return getDextoGlobalPath("images");
+}
+function getImageRegistryPath(storeDir = getDefaultImageStoreDir()) {
+  return path.join(storeDir, "registry.json");
+}
+function getImagePackagesDir(storeDir = getDefaultImageStoreDir()) {
+  return path.join(storeDir, "packages");
+}
+function getImagePackageInstallDir(imageId, version, storeDir = getDefaultImageStoreDir()) {
+  const packagesDir = getImagePackagesDir(storeDir);
+  const parts = imageId.startsWith("@") ? imageId.split("/") : [imageId];
+  return path.join(packagesDir, ...parts, version);
+}
+function loadImageRegistry(storeDir = getDefaultImageStoreDir()) {
+  const registryPath = getImageRegistryPath(storeDir);
+  if (!existsSync(registryPath)) {
+    return { version: 1, images: {} };
+  }
+  try {
+    const raw = JSON.parse(readFileSync(registryPath, "utf-8"));
+    const parsed = ImageRegistryFileSchema.safeParse(raw);
+    if (!parsed.success) {
+      return { version: 1, images: {} };
+    }
+    return parsed.data;
+  } catch {
+    return { version: 1, images: {} };
+  }
+}
+async function saveImageRegistry(data, storeDir = getDefaultImageStoreDir()) {
+  const registryPath = getImageRegistryPath(storeDir);
+  await fs.mkdir(path.dirname(registryPath), { recursive: true });
+  const tempPath = `${registryPath}.tmp.${Date.now()}`;
+  try {
+    await fs.writeFile(tempPath, JSON.stringify(data, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await fs.rename(tempPath, registryPath);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+}
+function parseImageSpecifier(specifier) {
+  const trimmed = specifier.trim();
+  if (!trimmed) {
+    throw new Error("Image specifier cannot be empty");
+  }
+  if (trimmed.startsWith("@")) {
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex === -1) {
+      return { id: trimmed };
+    }
+    const versionIndex2 = trimmed.indexOf("@", slashIndex + 1);
+    if (versionIndex2 === -1) {
+      return { id: trimmed };
+    }
+    const version = trimmed.slice(versionIndex2 + 1).trim();
+    return {
+      id: trimmed.slice(0, versionIndex2),
+      ...version.length > 0 ? { version } : {}
+    };
+  }
+  const versionIndex = trimmed.lastIndexOf("@");
+  if (versionIndex > 0) {
+    const version = trimmed.slice(versionIndex + 1).trim();
+    return {
+      id: trimmed.slice(0, versionIndex),
+      ...version.length > 0 ? { version } : {}
+    };
+  }
+  return { id: trimmed };
+}
+function isFileLikeImageSpecifier(specifier) {
+  if (specifier === "." || specifier === "..") return true;
+  if (specifier.startsWith("file://")) return true;
+  if (specifier.startsWith("~/")) return true;
+  if (specifier.startsWith("./") || specifier.startsWith("../")) return true;
+  if (path.isAbsolute(specifier)) return true;
+  if (/^[a-zA-Z]:[\\/]/.test(specifier)) return true;
+  return false;
+}
+function resolveFileLikeImageSpecifierToPath(specifier, cwd = process.cwd()) {
+  if (specifier.startsWith("file://")) {
+    return fileURLToPath(specifier);
+  }
+  if (specifier.startsWith("~/")) {
+    return path.join(homedir(), specifier.slice(2));
+  }
+  if (path.isAbsolute(specifier)) {
+    return specifier;
+  }
+  return path.resolve(cwd, specifier);
+}
+function resolveFileLikeImageSpecifierToFileUrl(specifier, cwd = process.cwd()) {
+  if (specifier.startsWith("file://")) {
+    return specifier;
+  }
+  const filePath = resolveFileLikeImageSpecifierToPath(specifier, cwd);
+  return pathToFileURL(filePath).href;
+}
+async function resolveImageEntryFileFromStore(specifier, storeDir = getDefaultImageStoreDir()) {
+  const registry = loadImageRegistry(storeDir);
+  const entry = registry.images[specifier.id];
+  if (!entry) {
+    return null;
+  }
+  const installedVersions = Object.keys(entry.installed);
+  if (installedVersions.length === 0) {
+    return null;
+  }
+  const resolvedVersion = specifier.version ?? entry.active;
+  if (!resolvedVersion) {
+    if (installedVersions.length === 1) {
+      return entry.installed[installedVersions[0] ?? ""]?.entryFile ?? null;
+    }
+    throw new Error(
+      `Image '${specifier.id}' has multiple installed versions but no active version set. Run: dexto image use ${specifier.id}@<version>`
+    );
+  }
+  const resolved = entry.installed[resolvedVersion];
+  if (!resolved) {
+    throw new Error(
+      `Image '${specifier.id}@${resolvedVersion}' is not installed. Run: dexto image install ${specifier.id}@${resolvedVersion}`
+    );
+  }
+  return resolved.entryFile;
+}
+async function setActiveImageVersion(imageId, version, storeDir = getDefaultImageStoreDir()) {
+  const registry = loadImageRegistry(storeDir);
+  const entry = registry.images[imageId];
+  if (!entry || !entry.installed[version]) {
+    throw new Error(`Image '${imageId}@${version}' is not installed`);
+  }
+  entry.active = version;
+  await saveImageRegistry(registry, storeDir);
+}
+async function removeImageFromStore(imageId, options = {}) {
+  const storeDir = options.storeDir ?? getDefaultImageStoreDir();
+  const version = options.version;
+  const registry = loadImageRegistry(storeDir);
+  const entry = registry.images[imageId];
+  if (!entry) {
+    return;
+  }
+  if (version) {
+    delete entry.installed[version];
+    if (entry.active === version) {
+      delete entry.active;
+    }
+    const installDir = getImagePackageInstallDir(imageId, version, storeDir);
+    await fs.rm(installDir, { recursive: true, force: true }).catch(() => {
+    });
+    if (Object.keys(entry.installed).length === 0) {
+      delete registry.images[imageId];
+    }
+  } else {
+    const versions = Object.keys(entry.installed);
+    for (const v of versions) {
+      const installDir = getImagePackageInstallDir(imageId, v, storeDir);
+      await fs.rm(installDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    delete registry.images[imageId];
+  }
+  await saveImageRegistry(registry, storeDir);
+}
+export {
+  getDefaultImageStoreDir,
+  getImagePackageInstallDir,
+  getImagePackagesDir,
+  getImageRegistryPath,
+  isFileLikeImageSpecifier,
+  loadImageRegistry,
+  parseImageSpecifier,
+  removeImageFromStore,
+  resolveFileLikeImageSpecifierToFileUrl,
+  resolveFileLikeImageSpecifierToPath,
+  resolveImageEntryFileFromStore,
+  saveImageRegistry,
+  setActiveImageVersion
+};