@platforma-sdk/block-tools 2.1.5 → 2.1.7

package/dist/cli.cjs

@@ -1,786 +0,0 @@
-'use strict';
-
-var core = require('@oclif/core');
-var path7 = require('path');
-var fs3 = require('fs');
-var zod = require('zod');
-var fsp = require('fs/promises');
-var mime = require('mime-types');
-var tar = require('tar');
-var plModelMiddleLayer = require('@milaboratories/pl-model-middle-layer');
-var tsHelpers = require('@milaboratories/ts-helpers');
-var YAML2 = require('yaml');
-var os = require('os');
-var crypto = require('crypto');
-var semver = require('semver/preload');
-var pathPosix = require('path/posix');
-var clientS3 = require('@aws-sdk/client-s3');
-var tsHelpersOclif = require('@milaboratories/ts-helpers-oclif');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var path7__default = /*#__PURE__*/_interopDefault(path7);
-var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
-var fsp__default = /*#__PURE__*/_interopDefault(fsp);
-var mime__namespace = /*#__PURE__*/_interopNamespace(mime);
-var tar__namespace = /*#__PURE__*/_interopNamespace(tar);
-var YAML2__default = /*#__PURE__*/_interopDefault(YAML2);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var semver__default = /*#__PURE__*/_interopDefault(semver);
-var pathPosix__default = /*#__PURE__*/_interopDefault(pathPosix);
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-function tryResolve(root, request) {
-  try {
-    return __require.resolve(request, {
-      paths: [root]
-    });
-  } catch (err) {
-    if (err.code !== "MODULE_NOT_FOUND") throw err;
-  }
-  return void 0;
-}
-function ResolvedModuleFile(moduleRoot) {
-  return zod.z.string().transform((request, ctx) => {
-    const result = tryResolve(moduleRoot, request);
-    if (result === void 0) {
-      ctx.addIssue({
-        code: zod.z.ZodIssueCode.custom,
-        message: `Can't resolve ${request} against ${moduleRoot}`
-      });
-      return zod.z.NEVER;
-    }
-    return {
-      type: "absolute-file",
-      file: result
-    };
-  });
-}
-function ResolvedModuleFolder(moduleRoot, ...indexFilesToLookFor) {
-  return zod.z.string().transform((request, ctx) => {
-    const requestWithSlash = request.endsWith("/") ? request : `${request}/`;
-    for (const idxFile of indexFilesToLookFor) {
-      const result = tryResolve(moduleRoot, requestWithSlash + idxFile);
-      if (result !== void 0) {
-        if (!result.endsWith(idxFile))
-          throw new Error(`Unexpected resolve result ${result} with index file ${idxFile}`);
-        return {
-          type: "absolute-folder",
-          folder: result.slice(0, result.length - idxFile.length)
-        };
-      }
-    }
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      message: `Can't resolve ${request} folder against ${moduleRoot}, no index file found (${indexFilesToLookFor.join(", ")})`
-    });
-    return zod.z.NEVER;
-  });
-}
-function mapLocalToAbsolute(root) {
-  return (value) => value.type === "relative" ? { type: "absolute-file", file: path7__default.default.resolve(root, value.path) } : value;
-}
-function absoluteToString() {
-  return async (value) => {
-    if (value.type === "absolute-file")
-      return await fsp__default.default.readFile(value.file, { encoding: "utf-8" });
-    else return value.content;
-  };
-}
-function absoluteToBase64() {
-  return async (value) => {
-    if (value.type === "absolute-file") {
-      const mimeType = mime__namespace.lookup(value.file);
-      if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.file}.`);
-      return {
-        type: "explicit-base64",
-        mimeType,
-        content: await fsp__default.default.readFile(value.file, { encoding: "base64" })
-      };
-    } else return value;
-  };
-}
-function cpAbsoluteToRelative(dstFolder, fileAccumulator) {
-  return async (value) => {
-    if (value.type === "absolute-file") {
-      const fileName = path7__default.default.basename(value.file);
-      const dst = path7__default.default.resolve(dstFolder, fileName);
-      fileAccumulator?.push(fileName);
-      await fsp__default.default.cp(value.file, dst);
-      return { type: "relative", path: fileName };
-    } else return value;
-  };
-}
-function packFolderToRelativeTgz(dstFolder, tgzName, fileAccumulator) {
-  if (!tgzName.endsWith(".tgz")) throw new Error(`Unexpected tgz file name: ${tgzName}`);
-  return async (value) => {
-    const dst = path7__default.default.resolve(dstFolder, tgzName);
-    await tar__namespace.create(
-      {
-        gzip: true,
-        file: dst,
-        cwd: value.folder
-      },
-      [value.folder]
-    );
-    fileAccumulator?.push(tgzName);
-    return { type: "relative", path: tgzName };
-  };
-}
-function BlockComponentsDescription(moduleRoot) {
-  return plModelMiddleLayer.BlockComponents(
-    ResolvedModuleFile(moduleRoot),
-    ResolvedModuleFolder(moduleRoot, "index.html")
-  );
-}
-function BlockComponentsConsolidate(dstFolder, fileAccumulator) {
-  return plModelMiddleLayer.BlockComponents(
-    plModelMiddleLayer.ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
-    plModelMiddleLayer.ContentAbsoluteFolder.transform(packFolderToRelativeTgz(dstFolder, "ui.tgz", fileAccumulator))
-  ).pipe(plModelMiddleLayer.BlockComponentsManifest);
-}
-function BlockPackMetaDescription(root) {
-  return plModelMiddleLayer.BlockPackMeta(
-    plModelMiddleLayer.DescriptionContentText.transform(mapLocalToAbsolute(root)),
-    plModelMiddleLayer.DescriptionContentBinary.transform(mapLocalToAbsolute(root))
-  );
-}
-function BlockPackMetaConsolidate(dstFolder, fileAccumulator) {
-  return plModelMiddleLayer.BlockPackMeta(
-    plModelMiddleLayer.ContentAbsoluteTextLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator)),
-    plModelMiddleLayer.ContentAbsoluteBinaryLocal.transform(cpAbsoluteToRelative(dstFolder, fileAccumulator))
-  );
-}
-var BlockPackMetaEmbed = plModelMiddleLayer.BlockPackMeta(
-  plModelMiddleLayer.ContentAbsoluteTextLocal.transform(absoluteToString()),
-  plModelMiddleLayer.ContentAbsoluteBinaryLocal.transform(absoluteToBase64())
-).pipe(plModelMiddleLayer.BlockPackMetaEmbeddedContent);
-
-// src/v2/model/index.ts
-function ResolvedBlockPackDescriptionFromPackageJson(root) {
-  return plModelMiddleLayer.CreateBlockPackDescriptionSchema(
-    BlockComponentsDescription(root),
-    BlockPackMetaDescription(root)
-  );
-}
-function BlockPackDescriptionConsolidateToFolder(dstFolder, fileAccumulator) {
-  return plModelMiddleLayer.CreateBlockPackDescriptionSchema(
-    BlockComponentsConsolidate(dstFolder, fileAccumulator),
-    //BlockPackMetaToExplicit
-    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
-  ).pipe(BlockPackDescriptionManifest);
-}
-var BlockPackDescriptionManifest = plModelMiddleLayer.CreateBlockPackDescriptionSchema(
-  plModelMiddleLayer.BlockComponentsManifest,
-  plModelMiddleLayer.BlockPackMetaManifest
-);
-var BlockPackManifest = BlockPackDescriptionManifest.extend({
-  schema: zod.z.literal("v1"),
-  files: zod.z.array(zod.z.string())
-});
-var BlockPackManifestFile = "manifest.json";
-async function buildBlockPackDist(description, dst) {
-  await fsp__default.default.mkdir(dst, { recursive: true });
-  const files = [];
-  const descriptionRelative = await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(
-    description
-  );
-  const manifest = BlockPackManifest.parse({
-    schema: "v1",
-    ...descriptionRelative,
-    files
-  });
-  await fsp__default.default.writeFile(path7__default.default.resolve(dst, BlockPackManifestFile), JSON.stringify(manifest));
-  return manifest;
-}
-async function tryLoadFile(file, map) {
-  try {
-    return map(await fsp__default.default.readFile(file));
-  } catch (err) {
-    if (err.code == "ENOENT") return void 0;
-    else throw new Error("", { cause: err });
-  }
-}
-var BlockDescriptionPackageJsonField = "block";
-var ConventionPackageNamePattern = /(?:@[a-zA-Z0-9-.]+\/)?(?<organization>[a-zA-Z0-9-]+)\.(?<name>[a-zA-Z0-9-]+)/;
-function parsePackageName(packageName) {
-  const match = packageName.match(ConventionPackageNamePattern);
-  if (!match)
-    throw new Error(
-      `Malformed package name (${packageName}), can't infer organization and block pack name.`
-    );
-  const { name, organization } = match.groups;
-  return { name, organization };
-}
-async function loadPackDescriptionRaw(moduleRoot) {
-  const fullPackageJsonPath = path7__default.default.resolve(moduleRoot, "package.json");
-  const packageJson = JSON.parse(await fsp__default.default.readFile(fullPackageJsonPath, { encoding: "utf-8" }));
-  const descriptionNotParsed = packageJson[BlockDescriptionPackageJsonField];
-  if (descriptionNotParsed === void 0)
-    throw new Error(
-      `Block description (field ${BlockDescriptionPackageJsonField}) not found in ${fullPackageJsonPath}.`
-    );
-  return {
-    ...plModelMiddleLayer.BlockPackDescriptionFromPackageJsonRaw.parse(descriptionNotParsed),
-    id: {
-      ...parsePackageName(
-        tsHelpers.notEmpty(packageJson["name"], `"name" not found in ${fullPackageJsonPath}`)
-      ),
-      version: plModelMiddleLayer.SemVer.parse(packageJson["version"])
-    }
-  };
-}
-async function loadPackDescription(moduleRoot) {
-  const descriptionRaw = await loadPackDescriptionRaw(moduleRoot);
-  return await ResolvedBlockPackDescriptionFromPackageJson(moduleRoot).parseAsync(descriptionRaw);
-}
-
-// src/cmd/build-meta.ts
-var BuildMeta = class _BuildMeta extends core.Command {
-  static description = "Extracts meta information from blocks package.json and outputs meta.json with embedded binary and textual information linked from the meta section.";
-  static flags = {
-    modulePath: core.Flags.string({
-      char: "i",
-      summary: "input module path",
-      helpValue: "<path>",
-      default: "."
-    }),
-    destination: core.Flags.string({
-      char: "o",
-      summary: "output meta.json file",
-      helpValue: "<path>",
-      required: true
-    })
-  };
-  async run() {
-    const { flags } = await this.parse(_BuildMeta);
-    const modulePath = path7__default.default.resolve(flags.modulePath);
-    const descriptionRaw = await loadPackDescriptionRaw(modulePath);
-    const metaEmbedded = await BlockPackMetaEmbed.parseAsync(
-      BlockPackMetaDescription(modulePath).parse(descriptionRaw.meta)
-    );
-    await fs3__namespace.default.promises.writeFile(path7__default.default.resolve(flags.destination), JSON.stringify(metaEmbedded));
-  }
-};
-async function getFileContent(path9) {
-  try {
-    return await fs3__namespace.default.promises.readFile(path9, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  }
-}
-var BuildModel = class _BuildModel extends core.Command {
-  static description = "Extracts and outputs block model JSON from pre-built block model module";
-  static flags = {
-    modulePath: core.Flags.string({
-      char: "i",
-      summary: "input module path",
-      helpValue: "<path>",
-      default: "."
-    }),
-    sourceBundle: core.Flags.string({
-      char: "b",
-      summary: "bundled model code to embed into the model for callback-based rendering to work",
-      helpValue: "<path>",
-      default: "./dist/bundle.js"
-    }),
-    destination: core.Flags.string({
-      char: "o",
-      summary: "output model file",
-      helpValue: "<path>",
-      default: "./dist/model.json"
-    })
-  };
-  async run() {
-    const { flags } = await this.parse(_BuildModel);
-    const modulePath = path7__default.default.resolve(flags.modulePath);
-    let { model, platforma } = __require(modulePath);
-    if (!model) model = platforma;
-    if (!model) throw new Error('"model" export not found');
-    const { config } = model;
-    if (!config)
-      throw new Error(
-        'Malformed "model" object, check it is created with "BlockModel" and ".done()" is executed as the call in the chain.'
-      );
-    if (!("canRun" in config || "inputsValid" in config) || !("outputs" in config) || !("sections" in config))
-      throw new Error('"config" has unexpected structure');
-    const code = await getFileContent(flags.sourceBundle);
-    if (code !== void 0) {
-      config.code = {
-        type: "plain",
-        content: code
-      };
-    }
-    await fs3__namespace.default.promises.writeFile(path7__default.default.resolve(flags.destination), JSON.stringify(config));
-  }
-};
-var PackBlock = class _PackBlock extends core.Command {
-  static description = "Builds block pack and outputs a block pack manifest consolidating all references assets into a single folder";
-  static flags = {
-    modulePath: core.Flags.string({
-      char: "i",
-      summary: "input module path",
-      helpValue: "<path>",
-      default: "."
-    }),
-    destinationPath: core.Flags.string({
-      char: "o",
-      summary: "output folder",
-      helpValue: "<path>",
-      default: "./block-pack"
-    })
-  };
-  async run() {
-    const { flags } = await this.parse(_PackBlock);
-    const description = await loadPackDescription(path7__default.default.resolve(flags.modulePath));
-    await buildBlockPackDist(description, path7__default.default.resolve(flags.destinationPath));
-  }
-};
-var PlRegAddress = zod.z.string().regex(/^(?:s3:|file:)/);
-var PlPackageConfigData = zod.z.object({
-  organization: zod.z.string(),
-  package: zod.z.string(),
-  version: plModelMiddleLayer.SemVer.optional(),
-  files: zod.z.record(zod.z.string().regex(/^[^\/]+$/), zod.z.string()).default({}),
-  meta: zod.z.object({}).passthrough()
-});
-var PlRegCommonConfigData = zod.z.object({
-  registries: zod.z.record(zod.z.string(), PlRegAddress).default({}),
-  registry: zod.z.string().optional()
-});
-var PlRegFullPackageConfigData = PlRegCommonConfigData.merge(PlPackageConfigData).required(
-  { registry: true, version: true }
-);
-var PlRegPackageConfigDataShard = PlRegFullPackageConfigData.partial().required({
-  registries: true,
-  files: true
-});
-var PlPackageJsonConfigFile = "pl.package.json";
-var PlPackageYamlConfigFile = "pl.package.yaml";
-
-// src/registry_v1/v1_repo_schema.ts
-var MainPrefix = "v1/";
-function payloadFilePath(bp, file) {
-  return `${MainPrefix}${bp.organization}/${bp.package}/${bp.version}/${file}`;
-}
-function packageOverviewPath(bp) {
-  return `${MainPrefix}${bp.organization}/${bp.package}/overview.json`;
-}
-var GlobalOverviewPath = `${MainPrefix}overview.json`;
-var MetaFile = "meta.json";
-
-// src/registry_v1/registry.ts
-var VersionUpdatesPrefix = "_updates_v1/per_package_version/";
-function packageUpdatePath(bp, seed) {
-  return `${VersionUpdatesPrefix}${bp.organization}/${bp.package}/${bp.version}/${seed}`;
-}
-var PackageUpdatePattern = /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<pkg>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/;
-var GlobalUpdateSeedInFile = "_updates_v1/_global_update_in";
-var GlobalUpdateSeedOutFile = "_updates_v1/_global_update_out";
-var BlockRegistry = class {
-  constructor(storage, logger) {
-    this.storage = storage;
-    this.logger = logger;
-  }
-  constructNewPackage(pack) {
-    return new BlockRegistryPackConstructor(this.storage, pack);
-  }
-  async updateRegistry() {
-    this.logger?.info("Initiating registry refresh...");
-    const packagesToUpdate = /* @__PURE__ */ new Map();
-    const seedPaths = [];
-    const rawSeedPaths = await this.storage.listFiles(VersionUpdatesPrefix);
-    this.logger?.info("Packages to be updated:");
-    for (const seedPath of rawSeedPaths) {
-      const match = seedPath.match(PackageUpdatePattern);
-      if (!match) continue;
-      seedPaths.push(seedPath);
-      const { packageKeyWithoutVersion, organization, pkg, version, seed } = match.groups;
-      let update = packagesToUpdate.get(packageKeyWithoutVersion);
-      if (!update) {
-        packagesToUpdate.set(packageKeyWithoutVersion, {
-          package: { organization, package: pkg },
-          versions: /* @__PURE__ */ new Set([version])
-        });
-      } else if (!update.versions.has(version)) {
-        update.versions.add(version);
-      }
-      this.logger?.info(`  - ${organization}:${pkg}:${version}`);
-    }
-    const overviewContent = await this.storage.getFile(GlobalOverviewPath);
-    let overview = overviewContent === void 0 ? [] : JSON.parse(overviewContent.toString());
-    this.logger?.info(`Global overview loaded, ${overview.length} records`);
-    for (const [, packageInfo] of packagesToUpdate.entries()) {
-      const overviewFile = packageOverviewPath(packageInfo.package);
-      const pOverviewContent = await this.storage.getFile(overviewFile);
-      let packageOverview = pOverviewContent === void 0 ? [] : JSON.parse(pOverviewContent.toString());
-      this.logger?.info(
-        `Updating ${packageInfo.package.organization}:${packageInfo.package.package} overview, ${packageOverview.length} records`
-      );
-      packageOverview = packageOverview.filter((e) => !packageInfo.versions.has(e.version));
-      for (const [v] of packageInfo.versions.entries()) {
-        const version = v.toString();
-        const metaContent = await this.storage.getFile(
-          payloadFilePath(
-            {
-              ...packageInfo.package,
-              version
-            },
-            MetaFile
-          )
-        );
-        if (!metaContent) continue;
-        packageOverview.push({ version, meta: JSON.parse(metaContent.toString()) });
-      }
-      packageOverview.sort((e1, e2) => semver__default.default.compare(e2.version, e1.version));
-      await this.storage.putFile(overviewFile, Buffer.from(JSON.stringify(packageOverview)));
-      this.logger?.info(`Done (${packageOverview.length} records)`);
-      overview = overview.filter(
-        (e) => e.organization !== packageInfo.package.organization || e.package !== packageInfo.package.package
-      );
-      overview.push({
-        organization: packageInfo.package.organization,
-        package: packageInfo.package.package,
-        allVersions: packageOverview.map((e) => e.version).reverse(),
-        latestVersion: packageOverview[0].version,
-        latestMeta: packageOverview[0].meta
-      });
-    }
-    await this.storage.putFile(GlobalOverviewPath, Buffer.from(JSON.stringify(overview)));
-    this.logger?.info(`Global overview updated (${overview.length} records)`);
-    await this.storage.deleteFiles(...seedPaths.map((sp) => `${VersionUpdatesPrefix}${sp}`));
-    this.logger?.info(`Version update requests cleared`);
-  }
-  async updateIfNeeded(force = false) {
-    this.logger?.info(`Checking if registry requires refresh...`);
-    const updateRequestSeed = await this.storage.getFile(GlobalUpdateSeedInFile);
-    const currentUpdatedSeed = await this.storage.getFile(GlobalUpdateSeedOutFile);
-    if (!force && updateRequestSeed === void 0 && currentUpdatedSeed === void 0) return;
-    if (!force && updateRequestSeed !== void 0 && currentUpdatedSeed !== void 0 && updateRequestSeed.equals(currentUpdatedSeed))
-      return;
-    await this.updateRegistry();
-    if (updateRequestSeed) {
-      await this.storage.putFile(GlobalUpdateSeedOutFile, updateRequestSeed);
-      this.logger?.info(`Refresh finished`);
-    }
-  }
-  async getPackageOverview(name) {
-    const content = await this.storage.getFile(packageOverviewPath(name));
-    if (content === void 0) return void 0;
-    return JSON.parse(content.toString());
-  }
-  async getGlobalOverview() {
-    const content = await this.storage.getFile(GlobalOverviewPath);
-    if (content === void 0) return void 0;
-    return JSON.parse(content.toString());
-  }
-};
-var BlockRegistryPackConstructor = class {
-  constructor(storage, name) {
-    this.storage = storage;
-    this.name = name;
-  }
-  metaAdded = false;
-  seed = crypto.randomUUID();
-  async addFile(file, content) {
-    await this.storage.putFile(payloadFilePath(this.name, file), content);
-  }
-  async writeMeta(meta) {
-    await this.addFile(MetaFile, Buffer.from(JSON.stringify(meta)));
-    this.metaAdded = true;
-  }
-  async finish() {
-    if (!this.metaAdded) throw new Error("meta not added");
-    await this.storage.putFile(packageUpdatePath(this.name, this.seed), Buffer.of(0));
-    await this.storage.putFile(GlobalUpdateSeedInFile, Buffer.from(this.seed));
-  }
-};
-var S3Storage = class {
-  constructor(client, bucket, root) {
-    this.client = client;
-    this.bucket = bucket;
-    this.root = root;
-  }
-  async getFile(file) {
-    try {
-      return Buffer.from(
-        await (await this.client.getObject({
-          Bucket: this.bucket,
-          Key: pathPosix__default.default.join(this.root, file)
-        })).Body.transformToByteArray()
-      );
-    } catch (e) {
-      if (e.name === "NoSuchKey") return void 0;
-      else throw e;
-    }
-  }
-  async listFiles(prefix) {
-    const listRoot = pathPosix__default.default.join(this.root, prefix);
-    const paginator = clientS3.paginateListObjectsV2(
-      { client: this.client },
-      {
-        Bucket: this.bucket,
-        Prefix: listRoot
-      }
-    );
-    const result = [];
-    for await (const page of paginator)
-      result.push(...page.Contents.map((e) => pathPosix__default.default.relative(listRoot, e.Key)));
-    return result;
-  }
-  async putFile(file, buffer) {
-    await this.client.putObject({
-      Bucket: this.bucket,
-      Key: pathPosix__default.default.join(this.root, file),
-      Body: buffer
-    });
-  }
-  async deleteFiles(...files) {
-    const results = await this.client.deleteObjects({
-      Bucket: this.bucket,
-      Delete: {
-        Objects: files.map((file) => ({
-          Key: pathPosix__default.default.join(this.root, file)
-        }))
-      }
-    });
-    if (results.Errors !== void 0 && results.Errors.length > 0)
-      throw new Error(`Errors encountered while deleting files: ${results.Errors.join("\n")}`);
-  }
-};
-var FSStorage = class {
-  /** Absolute path */
-  root;
-  constructor(_root) {
-    this.root = path7__default.default.resolve(_root);
-  }
-  toAbsolutePath(localPath) {
-    if (pathPosix__default.default.isAbsolute(localPath)) throw new Error("absolute path");
-    return path7__default.default.resolve(this.root, localPath.split(pathPosix__default.default.sep).join(path7__default.default.sep));
-  }
-  async getFile(address) {
-    try {
-      return await fs3__namespace.promises.readFile(this.toAbsolutePath(address));
-    } catch (err) {
-      if (err.code == "ENOENT") return void 0;
-      else throw new Error("", { cause: err });
-    }
-  }
-  async listFiles(prefix) {
-    try {
-      const listRoot = this.toAbsolutePath(prefix);
-      return (await fs3__namespace.promises.readdir(listRoot, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).map(
-        (e) => path7__default.default.relative(listRoot, path7__default.default.resolve(e.path, e.name)).split(path7__default.default.sep).join(pathPosix__default.default.sep)
-      );
-    } catch (err) {
-      if (err.code == "ENOENT") return [];
-      else throw new Error("", { cause: err });
-    }
-  }
-  async putFile(address, buffer) {
-    const absoluteAddress = this.toAbsolutePath(address);
-    await fs3__namespace.promises.mkdir(path7__default.default.dirname(absoluteAddress), { recursive: true });
-    await fs3__namespace.promises.writeFile(absoluteAddress, buffer);
-  }
-  async deleteFiles(...files) {
-    for (const file of files) await fs3__namespace.promises.rm(this.toAbsolutePath(file));
-  }
-};
-function storageByUrl(address) {
-  const url = new URL(address, `file:${path7__default.default.resolve(".").split(path7__default.default.sep).join(pathPosix__default.default.sep)}/`);
-  switch (url.protocol) {
-    case "file:":
-      const root = path7__default.default.resolve(url.pathname);
-      return new FSStorage(root);
-    case "s3:":
-      const options = {};
-      const region = url.searchParams.get("region");
-      if (region) options.region = region;
-      const bucket = url.hostname;
-      return new S3Storage(new clientS3.S3(options), bucket, url.pathname.replace(/^\//, ""));
-    default:
-      throw new Error(`Unknown protocol: ${url.protocol}`);
-  }
-}
-
-// src/registry_v1/config.ts
-function mergeConfigs(c1, c2) {
-  if (c2 === void 0) return c1;
-  return {
-    ...c1,
-    ...c2,
-    registries: { ...c1.registries, ...c2.registries },
-    files: { ...c1.files, ...c2.files }
-  };
-}
-async function tryLoadJsonConfigFromFile(file) {
-  return tryLoadFile(file, (buf) => PlRegPackageConfigDataShard.parse(JSON.parse(buf.toString())));
-}
-async function tryLoadYamlConfigFromFile(file) {
-  return tryLoadFile(file, (buf) => PlRegPackageConfigDataShard.parse(YAML2__default.default.parse(buf.toString())));
-}
-async function loadConfigShard() {
-  let conf = PlRegPackageConfigDataShard.parse({});
-  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile("./.pl.reg.json"));
-  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile("./.pl.reg.yaml"));
-  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile(`${os__namespace.homedir()}/.pl.reg.json`));
-  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile(`${os__namespace.homedir()}/.pl.reg.yaml`));
-  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile(PlPackageJsonConfigFile));
-  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile(PlPackageYamlConfigFile));
-  return conf;
-}
-var PlRegPackageConfig = class {
-  constructor(conf) {
-    this.conf = conf;
-  }
-  createRegistry(logger) {
-    let address = this.conf.registry;
-    if (!address.startsWith("file:") && !address.startsWith("s3:")) {
-      const regByAlias = this.conf.registries[address];
-      if (!regByAlias) throw new Error(`Registry with alias "${address}" not found`);
-      address = regByAlias;
-    }
-    return new BlockRegistry(storageByUrl(address), logger);
-  }
-  get fullPackageName() {
-    return {
-      organization: this.conf.organization,
-      package: this.conf.package,
-      version: this.conf.version
-    };
-  }
-};
-async function getConfig(finalShard) {
-  const confShard = await loadConfigShard();
-  return new PlRegPackageConfig(
-    PlRegFullPackageConfigData.parse(mergeConfigs(confShard, finalShard))
-  );
-}
-function parseTargetFile(arg) {
-  const match = arg.match(/(?<destName>[^\/\\]+)=(?<src>.*)/);
-  if (match) {
-    const { src, destName } = match.groups;
-    return { src, destName };
-  } else {
-    return { src: arg, destName: path7__default.default.basename(arg) };
-  }
-}
-var targetFile = core.Flags.custom({
-  summary: "target files to upload",
-  helpValue: "file_path | package_name=file_path",
-  parse: async (arg) => parseTargetFile(arg)
-});
-var BasicConfigFields = ["registry", "organization", "package", "version"];
-var UploadPackageV1 = class _UploadPackageV1 extends core.Command {
-  static description = "Uploads V1 package and refreshes the registry";
-  static flags = {
-    registry: core.Flags.string({
-      char: "r",
-      summary: "full address of the registry or alias from .pl.reg",
-      helpValue: "<address|alias>",
-      env: "PL_REGISTRY"
-    }),
-    organization: core.Flags.string({
-      char: "o",
-      summary: "target organisation",
-      env: "PL_PACKAGE_ORGANIZATION"
-    }),
-    package: core.Flags.string({
-      char: "p",
-      summary: "target package",
-      env: "PL_PACKAGE_NAME"
-    }),
-    version: core.Flags.string({
-      char: "v",
-      summary: "target version",
-      env: "PL_PACKAGE_VERSION"
-    }),
-    meta: core.Flags.file({
-      char: "m",
-      summary: "json file containing meta information to associate with tha package",
-      exists: true
-    }),
-    file: targetFile({
-      char: "f",
-      summary: "package files",
-      multiple: true,
-      default: []
-    }),
-    refresh: core.Flags.boolean({
-      summary: "refresh repository after adding the package",
-      default: true,
-      allowNo: true,
-      env: "PL_REGISTRY_REFRESH"
-    })
-  };
-  async run() {
-    const { flags } = await this.parse(_UploadPackageV1);
-    const configFromFlags = PlRegPackageConfigDataShard.parse({});
-    for (const field of BasicConfigFields) if (flags[field]) configFromFlags[field] = flags[field];
-    if (flags.meta) {
-      if (flags.meta.endsWith(".json"))
-        configFromFlags.meta = JSON.parse(
-          await fs3__namespace.default.promises.readFile(flags.meta, { encoding: "utf-8" })
-        );
-      else if (flags.meta.endsWith(".yaml"))
-        configFromFlags.meta = YAML2__default.default.parse(
-          await fs3__namespace.default.promises.readFile(flags.meta, { encoding: "utf-8" })
-        );
-    }
-    for (const targetFile2 of flags.file) {
-      configFromFlags.files[targetFile2.destName] = targetFile2.src;
-    }
-    const conf = await getConfig(configFromFlags);
-    this.log(YAML2__default.default.stringify(conf.conf));
-    const registry = conf.createRegistry(new tsHelpersOclif.OclifLoggerAdapter(this));
-    const name = conf.fullPackageName;
-    const builder = registry.constructNewPackage(name);
-    for (const [dst, src] of Object.entries(conf.conf.files)) {
-      this.log(`Uploading ${src} -> ${dst} ...`);
-      const content = await fs3__namespace.default.promises.readFile(src);
-      await builder.addFile(dst, content);
-    }
-    this.log(`Uploading meta information...`);
-    await builder.writeMeta(conf.conf.meta);
-    await builder.finish();
-    if (flags.refresh) await registry.updateIfNeeded();
-  }
-};
-
-// src/cmd/index.ts
-var COMMANDS = {
-  "upload-package-v1": UploadPackageV1,
-  "pack": PackBlock,
-  "build-model": BuildModel,
-  "build-meta": BuildMeta
-};
-
-exports.COMMANDS = COMMANDS;
-//# sourceMappingURL=cli.cjs.map
-//# sourceMappingURL=cli.cjs.map