@platforma-sdk/block-tools 2.6.63 → 2.6.64

package/dist/cli.mjs

@@ -1,426 +1,381 @@
-var D = Object.defineProperty;
-var M = (o, e, t) => e in o ? D(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
-var i = (o, e, t) => M(o, typeof e != "symbol" ? e + "" : e, t);
-import { Command as m, Flags as s } from "@oclif/core";
-import d from "node:path";
-import p from "node:fs";
-import "zod";
-import "mime-types";
-import "tar";
-import "@milaboratories/resolve-helper";
-import { l as Y, B, a as J, s as R, b as N, c as H, d as U, M as K, P as z, g as W } from "./config-Cc8_zV3b.mjs";
-import { StableChannel as F, overrideDescriptionVersion as _, BlockPackManifest as Z, overrideManifestVersion as Q } from "@milaboratories/pl-model-middle-layer";
-import "@milaboratories/pl-model-common";
-import "@milaboratories/ts-helpers";
-import "canonicalize";
-import "lru-cache";
-import { OclifLoggerAdapter as u } from "@milaboratories/ts-helpers-oclif";
-import "undici";
-import "@milaboratories/pl-http";
-import q from "yaml";
-import { execFileSync as X } from "node:child_process";
-import { createRequire as ee } from "node:module";
-const h = class h extends m {
-  async run() {
-    const { flags: e } = await this.parse(h), t = d.resolve(e.modulePath), a = await Y(t), r = await B.parseAsync(
-      J(t).parse(a.meta)
-    );
-    await p.promises.writeFile(d.resolve(e.destination), JSON.stringify(r));
-  }
+import { Ct as e, F as t, J as n, Q as r, Y as i, _ as a, b as o, n as s, ot as c, p as l, st as u } from "./config-CZZ2gdZH.mjs";
+import { Command as d, Flags as f } from "@oclif/core";
+import p from "node:path";
+import m from "node:fs";
+import { BlockPackManifest as h, StableChannel as g, overrideDescriptionVersion as _, overrideManifestVersion as v } from "@milaboratories/pl-model-middle-layer";
+import { OclifLoggerAdapter as y } from "@milaboratories/ts-helpers-oclif";
+import b from "yaml";
+import { execFileSync as x } from "node:child_process";
+import { createRequire as S } from "node:module";
+var C = class e extends d {
+	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: f.string({
+			char: "i",
+			summary: "input module path",
+			helpValue: "<path>",
+			default: "."
+		}),
+		destination: f.string({
+			char: "o",
+			summary: "output meta.json file",
+			helpValue: "<path>",
+			required: !0
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e), n = p.resolve(t.modulePath), r = await i(n), a = await u.parseAsync(c(n).parse(r.meta));
+		await m.promises.writeFile(p.resolve(t.destination), JSON.stringify(a));
+	}
 };
-i(h, "description", "Extracts meta information from blocks package.json and outputs meta.json with embedded binary and textual information linked from the meta section."), i(h, "flags", {
-  modulePath: s.string({
-    char: "i",
-    summary: "input module path",
-    helpValue: "<path>",
-    default: "."
-  }),
-  destination: s.string({
-    char: "o",
-    summary: "output meta.json file",
-    helpValue: "<path>",
-    required: !0
-  })
-});
-let x = h;
-async function te(o) {
-  try {
-    return await p.promises.readFile(o, "utf8");
-  } catch (e) {
-    if (e instanceof Error && "code" in e && e.code === "ENOENT")
-      return;
-    throw e;
-  }
+async function w(e) {
+	try {
+		return await m.promises.readFile(e, "utf8");
+	} catch (e) {
+		if (e instanceof Error && "code" in e && e.code === "ENOENT") return;
+		throw e;
+	}
 }
-const g = class g extends m {
-  async run() {
-    const { flags: e } = await this.parse(g), t = d.resolve(e.modulePath);
-    let { model: a, platforma: r } = require(t);
-    if (a || (a = r), !a) throw new Error('"model" export not found');
-    const { config: c } = a;
-    if (!c)
-      throw new Error(
-        'Malformed "model" object, check it is created with "BlockModel" and ".done()" is executed as the call in the chain.'
-      );
-    if (!("outputs" in c) || !("sections" in c))
-      throw new Error('"config" has unexpected structure');
-    const l = await te(e.sourceBundle);
-    l !== void 0 && (c.code = {
-      type: "plain",
-      content: l
-    }), await p.promises.writeFile(d.resolve(e.destination), JSON.stringify(c));
-  }
-};
-i(g, "description", "Extracts and outputs block model JSON from pre-built block model module"), i(g, "flags", {
-  modulePath: s.string({
-    char: "i",
-    summary: "input module path",
-    helpValue: "<path>",
-    default: "."
-  }),
-  sourceBundle: s.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: s.string({
-    char: "o",
-    summary: "output model file",
-    helpValue: "<path>",
-    default: "./dist/model.json"
-  })
-});
-let A = g;
-const y = class y extends m {
-  async run() {
-    const { flags: e } = await this.parse(y), t = R(e.registry), r = await new N(t, new u(this)).listGlobalOverviewSnapshots();
-    if (e.json)
-      this.log(JSON.stringify(r, null, 2));
-    else if (r.length === 0)
-      this.log("No snapshots found.");
-    else {
-      this.log(`Found ${r.length} snapshot(s):
-`);
-      for (const c of r)
-        this.log(`  ${c.timestamp}`), this.log(`    Path: ${c.path}`), this.log("");
-    }
-  }
-};
-i(y, "description", "List all available global overview snapshots in the registry"), i(y, "flags", {
-  registry: s.string({
-    char: "r",
-    summary: "full address of the registry",
-    helpValue: "<address>",
-    env: "PL_REGISTRY",
-    required: !0
-  }),
-  json: s.boolean({
-    summary: "output in JSON format",
-    default: !1
-  })
-});
-let I = y;
-const w = class w extends m {
-  async run() {
-    const { flags: e } = await this.parse(w);
-    let t = await Y(d.resolve(e.modulePath));
-    e["version-override"] && (t = _(t, e["version-override"]));
-    const a = R(e.registry), r = new N(a, new u(this));
-    e.unmark ? await r.removePackageFromChannel(t.id, e.channel) : await r.addPackageToChannel(t.id, e.channel), e.refresh && await r.updateIfNeeded();
-  }
-};
-i(w, "description", "Mark target block stable"), i(w, "flags", {
-  modulePath: s.string({
-    char: "i",
-    summary: "input module path",
-    helpValue: "<path>",
-    default: "."
-  }),
-  channel: s.string({
-    char: "c",
-    hidden: !0,
-    summary: "custom channel",
-    helpValue: "<channel name>",
-    default: F
-  }),
-  "version-override": s.file({
-    char: "v",
-    summary: "override package version"
-  }),
-  registry: s.string({
-    char: "r",
-    summary: "full address of the registry",
-    helpValue: "<address>",
-    env: "PL_REGISTRY",
-    required: !0
-  }),
-  refresh: s.boolean({
-    summary: "refresh repository after adding the package",
-    default: !0,
-    allowNo: !0,
-    env: "PL_REGISTRY_REFRESH"
-  }),
-  unmark: s.boolean({
-    summary: 'reverses meaning of this command, flag can be used to remove "stable" flag from the package',
-    default: !1
-  })
-});
-let V = w;
-const v = class v extends m {
-  async run() {
-    const { flags: e } = await this.parse(v), t = await H(d.resolve(e.modulePath));
-    await U(t, d.resolve(e.destinationPath));
-  }
+var T = class t extends d {
+	static description = "Extracts and outputs block model JSON from pre-built block model module";
+	static flags = {
+		modulePath: f.string({
+			char: "i",
+			summary: "input module path",
+			helpValue: "<path>",
+			default: "."
+		}),
+		sourceBundle: f.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: f.string({
+			char: "o",
+			summary: "output model file",
+			helpValue: "<path>",
+			default: "./dist/model.json"
+		})
+	};
+	async run() {
+		let { flags: n } = await this.parse(t), { model: r, platforma: i } = e(p.resolve(n.modulePath));
+		if (r ||= i, !r) throw Error("\"model\" export not found");
+		let { config: a } = r;
+		if (!a) throw Error("Malformed \"model\" object, check it is created with \"BlockModel\" and \".done()\" is executed as the call in the chain.");
+		if (!("outputs" in a) || !("sections" in a)) throw Error("\"config\" has unexpected structure");
+		let o = await w(n.sourceBundle);
+		o !== void 0 && (a.code = {
+			type: "plain",
+			content: o
+		}), await m.promises.writeFile(p.resolve(n.destination), JSON.stringify(a));
+	}
+}, E = class e extends d {
+	static description = "List all available global overview snapshots in the registry";
+	static flags = {
+		registry: f.string({
+			char: "r",
+			summary: "full address of the registry",
+			helpValue: "<address>",
+			env: "PL_REGISTRY",
+			required: !0
+		}),
+		json: f.boolean({
+			summary: "output in JSON format",
+			default: !1
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e), n = await new o(a(t.registry), new y(this)).listGlobalOverviewSnapshots();
+		if (t.json) this.log(JSON.stringify(n, null, 2));
+		else if (n.length === 0) this.log("No snapshots found.");
+		else {
+			this.log(`Found ${n.length} snapshot(s):\n`);
+			for (let e of n) this.log(`  ${e.timestamp}`), this.log(`    Path: ${e.path}`), this.log("");
+		}
+	}
+}, D = class e extends d {
+	static description = "Mark target block stable";
+	static flags = {
+		modulePath: f.string({
+			char: "i",
+			summary: "input module path",
+			helpValue: "<path>",
+			default: "."
+		}),
+		channel: f.string({
+			char: "c",
+			hidden: !0,
+			summary: "custom channel",
+			helpValue: "<channel name>",
+			default: g
+		}),
+		"version-override": f.file({
+			char: "v",
+			summary: "override package version"
+		}),
+		registry: f.string({
+			char: "r",
+			summary: "full address of the registry",
+			helpValue: "<address>",
+			env: "PL_REGISTRY",
+			required: !0
+		}),
+		refresh: f.boolean({
+			summary: "refresh repository after adding the package",
+			default: !0,
+			allowNo: !0,
+			env: "PL_REGISTRY_REFRESH"
+		}),
+		unmark: f.boolean({
+			summary: "reverses meaning of this command, flag can be used to remove \"stable\" flag from the package",
+			default: !1
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e), n = await i(p.resolve(t.modulePath));
+		t["version-override"] && (n = _(n, t["version-override"]));
+		let r = new o(a(t.registry), new y(this));
+		t.unmark ? await r.removePackageFromChannel(n.id, t.channel) : await r.addPackageToChannel(n.id, t.channel), t.refresh && await r.updateIfNeeded();
+	}
+}, O = class e extends d {
+	static description = "Builds block pack and outputs a block pack manifest consolidating all references assets into a single folder";
+	static flags = {
+		modulePath: f.string({
+			char: "i",
+			summary: "input module path",
+			helpValue: "<path>",
+			default: "."
+		}),
+		destinationPath: f.string({
+			char: "o",
+			summary: "output folder",
+			helpValue: "<path>",
+			default: "./block-pack"
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e);
+		await r(await n(p.resolve(t.modulePath)), p.resolve(t.destinationPath));
+	}
 };
-i(v, "description", "Builds block pack and outputs a block pack manifest consolidating all references assets into a single folder"), i(v, "flags", {
-  modulePath: s.string({
-    char: "i",
-    summary: "input module path",
-    helpValue: "<path>",
-    default: "."
-  }),
-  destinationPath: s.string({
-    char: "o",
-    summary: "output folder",
-    helpValue: "<path>",
-    default: "./block-pack"
-  })
-});
-let L = v;
-function O(o, e) {
-  const t = { ...o };
-  for (const a in e)
-    e[a] && typeof e[a] == "object" && !Array.isArray(e[a]) && t[a] && typeof t[a] == "object" && !Array.isArray(t[a]) ? t[a] = O(
-      t[a],
-      e[a]
-    ) : t[a] = e[a];
-  return t;
+function k(e, t) {
+	let n = { ...e };
+	for (let e in t) t[e] && typeof t[e] == "object" && !Array.isArray(t[e]) && n[e] && typeof n[e] == "object" && !Array.isArray(n[e]) ? n[e] = k(n[e], t[e]) : n[e] = t[e];
+	return n;
 }
-const b = class b extends m {
-  async run() {
-    const { flags: e } = await this.parse(b), t = d.resolve(e.manifest), a = JSON.parse(
-      await p.promises.readFile(t, { encoding: "utf-8" })
-    );
-    let r = Z.parse(a);
-    r = O(
-      a,
-      r
-    );
-    const c = d.dirname(t);
-    this.log(`Manifest root = ${c}`), e["version-override"] && (r = Q(r, e["version-override"]));
-    const l = R(e.registry), n = new N(l, new u(this));
-    await n.publishPackage(
-      r,
-      async (f) => Buffer.from(await p.promises.readFile(d.resolve(c, f)))
-    ), e.unstable || (this.log(`Adding package to ${F} channel...`), await n.addPackageToChannel(r.description.id, F)), e.refresh && await n.updateIfNeeded();
-  }
+var A = class e extends d {
+	static description = "Publishes the block package and refreshes the registry (for v2 block-pack schema)";
+	static flags = {
+		registry: f.string({
+			char: "r",
+			summary: "full address of the registry",
+			helpValue: "<address>",
+			env: "PL_REGISTRY",
+			required: !0
+		}),
+		manifest: f.file({
+			char: "m",
+			summary: "manifest file path",
+			exists: !0,
+			default: `./block-pack/${t}`
+		}),
+		"version-override": f.file({
+			char: "v",
+			summary: "override package version"
+		}),
+		refresh: f.boolean({
+			summary: "refresh repository after adding the package",
+			default: !0,
+			allowNo: !0,
+			env: "PL_REGISTRY_REFRESH"
+		}),
+		unstable: f.boolean({
+			summary: "do not add the published package to stable channel",
+			default: !1,
+			env: "PL_PUBLISH_UNSTABLE"
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e), n = p.resolve(t.manifest), r = JSON.parse(await m.promises.readFile(n, { encoding: "utf-8" })), i = h.parse(r);
+		i = k(r, i);
+		let s = p.dirname(n);
+		this.log(`Manifest root = ${s}`), t["version-override"] && (i = v(i, t["version-override"]));
+		let c = new o(a(t.registry), new y(this));
+		await c.publishPackage(i, async (e) => Buffer.from(await m.promises.readFile(p.resolve(s, e)))), t.unstable || (this.log(`Adding package to ${g} channel...`), await c.addPackageToChannel(i.description.id, g)), t.refresh && await c.updateIfNeeded();
+	}
+}, j = class e extends d {
+	static description = "Refresh overview files based on published but not proecessed artefacts";
+	static flags = {
+		registry: f.string({
+			char: "r",
+			summary: "full address of the registry",
+			helpValue: "<address>",
+			env: "PL_REGISTRY",
+			required: !0
+		}),
+		mode: f.string({
+			char: "m",
+			summary: "refresh mode (allowed valiues: \"force\", \"normal\", \"dry-run\")",
+			helpValue: "<mode>",
+			options: [
+				"force",
+				"normal",
+				"dry-run"
+			],
+			env: "PL_REGISTRY_REFRESH_DRY_RUN",
+			default: "normal"
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e);
+		await new o(a(t.registry), new y(this)).updateIfNeeded(t.mode);
+	}
+}, M = class e extends d {
+	static description = "Restore global overview from a snapshot";
+	static flags = {
+		registry: f.string({
+			char: "r",
+			summary: "full address of the registry",
+			helpValue: "<address>",
+			env: "PL_REGISTRY",
+			required: !0
+		}),
+		snapshot: f.string({
+			char: "s",
+			summary: "snapshot timestamp ID to restore from",
+			helpValue: "<timestamp>",
+			required: !0
+		}),
+		"skip-confirmation": f.boolean({
+			summary: "skip confirmation prompt (use with caution)",
+			default: !1
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e), n = new o(a(t.registry), new y(this)), r = await n.listGlobalOverviewSnapshots();
+		if (r.find((e) => e.timestamp === t.snapshot) || this.error(`Snapshot '${t.snapshot}' not found. Available snapshots:\n${r.map((e) => `  - ${e.timestamp}`).join("\n") || "  (none)"}`), !t["skip-confirmation"]) {
+			let e = (await import("node:readline")).createInterface({
+				input: process.stdin,
+				output: process.stdout
+			}), n = await new Promise((n) => {
+				e.question(`⚠️  This will overwrite the current global overview with snapshot '${t.snapshot}'.\nAre you sure you want to continue? (y/N): `, n);
+			});
+			if (e.close(), n.toLowerCase() !== "y" && n.toLowerCase() !== "yes") {
+				this.log("Restore cancelled.");
+				return;
+			}
+		}
+		try {
+			await n.restoreGlobalOverviewFromSnapshot(t.snapshot), this.log(`✅ Successfully restored global overview from snapshot '${t.snapshot}'`);
+		} catch (e) {
+			this.error(`Failed to restore from snapshot: ${String(e)}`);
+		}
+	}
 };
-i(b, "description", "Publishes the block package and refreshes the registry (for v2 block-pack schema)"), i(b, "flags", {
-  registry: s.string({
-    char: "r",
-    summary: "full address of the registry",
-    helpValue: "<address>",
-    env: "PL_REGISTRY",
-    required: !0
-  }),
-  manifest: s.file({
-    char: "m",
-    summary: "manifest file path",
-    exists: !0,
-    default: `./block-pack/${K}`
-  }),
-  "version-override": s.file({
-    char: "v",
-    summary: "override package version"
-  }),
-  refresh: s.boolean({
-    summary: "refresh repository after adding the package",
-    default: !0,
-    allowNo: !0,
-    env: "PL_REGISTRY_REFRESH"
-  }),
-  unstable: s.boolean({
-    summary: "do not add the published package to stable channel",
-    default: !1,
-    env: "PL_PUBLISH_UNSTABLE"
-  })
-});
-let G = b;
-const k = class k extends m {
-  async run() {
-    const { flags: e } = await this.parse(k), t = R(e.registry);
-    await new N(t, new u(this)).updateIfNeeded(e.mode);
-  }
-};
-i(k, "description", "Refresh overview files based on published but not proecessed artefacts"), i(k, "flags", {
-  registry: s.string({
-    char: "r",
-    summary: "full address of the registry",
-    helpValue: "<address>",
-    env: "PL_REGISTRY",
-    required: !0
-  }),
-  mode: s.string({
-    char: "m",
-    summary: 'refresh mode (allowed valiues: "force", "normal", "dry-run")',
-    helpValue: "<mode>",
-    options: ["force", "normal", "dry-run"],
-    env: "PL_REGISTRY_REFRESH_DRY_RUN",
-    default: "normal"
-  })
-});
-let T = k;
-const P = class P extends m {
-  async run() {
-    const { flags: e } = await this.parse(P), t = R(e.registry), a = new N(t, new u(this)), r = await a.listGlobalOverviewSnapshots();
-    if (r.find((l) => l.timestamp === e.snapshot) || this.error(
-      `Snapshot '${e.snapshot}' not found. Available snapshots:
-${r.map((l) => `  - ${l.timestamp}`).join(`
-`) || "  (none)"}`
-    ), !e["skip-confirmation"]) {
-      const n = (await import("node:readline")).createInterface({
-        input: process.stdin,
-        output: process.stdout
-      }), f = await new Promise((S) => {
-        n.question(
-          `⚠️  This will overwrite the current global overview with snapshot '${e.snapshot}'.
-Are you sure you want to continue? (y/N): `,
-          S
-        );
-      });
-      if (n.close(), f.toLowerCase() !== "y" && f.toLowerCase() !== "yes") {
-        this.log("Restore cancelled.");
-        return;
-      }
-    }
-    try {
-      await a.restoreGlobalOverviewFromSnapshot(e.snapshot), this.log(`✅ Successfully restored global overview from snapshot '${e.snapshot}'`);
-    } catch (l) {
-      this.error(`Failed to restore from snapshot: ${String(l)}`);
-    }
-  }
-};
-i(P, "description", "Restore global overview from a snapshot"), i(P, "flags", {
-  registry: s.string({
-    char: "r",
-    summary: "full address of the registry",
-    helpValue: "<address>",
-    env: "PL_REGISTRY",
-    required: !0
-  }),
-  snapshot: s.string({
-    char: "s",
-    summary: "snapshot timestamp ID to restore from",
-    helpValue: "<timestamp>",
-    required: !0
-  }),
-  "skip-confirmation": s.boolean({
-    summary: "skip confirmation prompt (use with caution)",
-    default: !1
-  })
-});
-let j = P;
-function ae(o) {
-  const e = o.match(/(?<destName>[^/\\]+)=(?<src>.*)/);
-  if (e) {
-    const { src: t, destName: a } = e.groups;
-    return { src: t, destName: a };
-  } else
-    return { src: o, destName: d.basename(o) };
+function N(e) {
+	let t = e.match(/(?<destName>[^/\\]+)=(?<src>.*)/);
+	if (t) {
+		let { src: e, destName: n } = t.groups;
+		return {
+			src: e,
+			destName: n
+		};
+	} else return {
+		src: e,
+		destName: p.basename(e)
+	};
 }
-const se = s.custom({
-  summary: "target files to upload",
-  helpValue: "file_path | package_name=file_path",
-  // eslint-disable-next-line @typescript-eslint/require-await -- oclif requires async but parsing is sync
-  parse: async (o) => ae(o)
-}), re = ["registry", "organization", "package", "version"], E = class E extends m {
-  async run() {
-    const { flags: e } = await this.parse(E), t = z.parse({});
-    for (const n of re) e[n] && (t[n] = e[n]);
-    e.meta && (e.meta.endsWith(".json") ? t.meta = JSON.parse(
-      await p.promises.readFile(e.meta, { encoding: "utf-8" })
-    ) : e.meta.endsWith(".yaml") && (t.meta = q.parse(
-      await p.promises.readFile(e.meta, { encoding: "utf-8" })
-    )));
-    for (const n of e.file)
-      t.files[n.destName] = n.src;
-    const a = await W(t);
-    this.log(q.stringify(a.conf));
-    const r = a.createRegistry(new u(this)), c = a.fullPackageName, l = r.constructNewPackage(c);
-    for (const [n, f] of Object.entries(a.conf.files)) {
-      this.log(`Uploading ${f} -> ${n} ...`);
-      const S = await p.promises.readFile(f);
-      await l.addFile(n, S);
-    }
-    this.log("Uploading meta information..."), await l.writeMeta(a.conf.meta), await l.finish(), e.refresh && await r.updateIfNeeded();
-  }
-};
-i(E, "description", "Uploads V1 package and refreshes the registry"), i(E, "flags", {
-  registry: s.string({
-    char: "r",
-    summary: "full address of the registry or alias from .pl.reg",
-    helpValue: "<address|alias>",
-    env: "PL_REGISTRY"
-  }),
-  organization: s.string({
-    char: "o",
-    summary: "target organisation",
-    env: "PL_PACKAGE_ORGANIZATION"
-  }),
-  package: s.string({
-    char: "p",
-    summary: "target package",
-    env: "PL_PACKAGE_NAME"
-  }),
-  version: s.string({
-    char: "v",
-    summary: "target version",
-    env: "PL_PACKAGE_VERSION"
-  }),
-  meta: s.file({
-    char: "m",
-    summary: "json file containing meta information to associate with tha package",
-    exists: !0
-  }),
-  file: se({
-    char: "f",
-    summary: "package files",
-    multiple: !0,
-    default: []
-  }),
-  refresh: s.boolean({
-    summary: "refresh repository after adding the package",
-    default: !0,
-    allowNo: !0,
-    env: "PL_REGISTRY_REFRESH"
-  })
+const P = f.custom({
+	summary: "target files to upload",
+	helpValue: "file_path | package_name=file_path",
+	parse: async (e) => N(e)
 });
-let C = E;
-class $ extends m {
-  // eslint-disable-next-line @typescript-eslint/require-await -- oclif requires async but implementation is sync
-  async run() {
-    const t = ee(import.meta.url).resolve("@platforma-sdk/blocks-deps-updater/scripts/updater.js");
-    X(process.execPath, [t], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    });
-  }
-}
-i($, "description", "Updates @platforma-sdk and @milaboratories packages in pnpm-workspace.yaml catalog to their latest versions from npm registry."), i($, "examples", ["<%= config.bin %> <%= command.id %>"]);
-const Ne = {
-  "build-meta": x,
-  "build-model": A,
-  "list-overview-snapshots": I,
-  "mark-stable": V,
-  pack: L,
-  publish: G,
-  "refresh-registry": T,
-  "restore-overview-from-snapshot": j,
-  "upload-package-v1": C,
-  "update-deps": $
+var F = [
+	"registry",
+	"organization",
+	"package",
+	"version"
+], I = class e extends d {
+	static description = "Uploads V1 package and refreshes the registry";
+	static flags = {
+		registry: f.string({
+			char: "r",
+			summary: "full address of the registry or alias from .pl.reg",
+			helpValue: "<address|alias>",
+			env: "PL_REGISTRY"
+		}),
+		organization: f.string({
+			char: "o",
+			summary: "target organisation",
+			env: "PL_PACKAGE_ORGANIZATION"
+		}),
+		package: f.string({
+			char: "p",
+			summary: "target package",
+			env: "PL_PACKAGE_NAME"
+		}),
+		version: f.string({
+			char: "v",
+			summary: "target version",
+			env: "PL_PACKAGE_VERSION"
+		}),
+		meta: f.file({
+			char: "m",
+			summary: "json file containing meta information to associate with tha package",
+			exists: !0
+		}),
+		file: P({
+			char: "f",
+			summary: "package files",
+			multiple: !0,
+			default: []
+		}),
+		refresh: f.boolean({
+			summary: "refresh repository after adding the package",
+			default: !0,
+			allowNo: !0,
+			env: "PL_REGISTRY_REFRESH"
+		})
+	};
+	async run() {
+		let { flags: t } = await this.parse(e), n = l.parse({});
+		for (let e of F) t[e] && (n[e] = t[e]);
+		t.meta && (t.meta.endsWith(".json") ? n.meta = JSON.parse(await m.promises.readFile(t.meta, { encoding: "utf-8" })) : t.meta.endsWith(".yaml") && (n.meta = b.parse(await m.promises.readFile(t.meta, { encoding: "utf-8" }))));
+		for (let e of t.file) n.files[e.destName] = e.src;
+		let r = await s(n);
+		this.log(b.stringify(r.conf));
+		let i = r.createRegistry(new y(this)), a = r.fullPackageName, o = i.constructNewPackage(a);
+		for (let [e, t] of Object.entries(r.conf.files)) {
+			this.log(`Uploading ${t} -> ${e} ...`);
+			let n = await m.promises.readFile(t);
+			await o.addFile(e, n);
+		}
+		this.log("Uploading meta information..."), await o.writeMeta(r.conf.meta), await o.finish(), t.refresh && await i.updateIfNeeded();
+	}
+}, L = class extends d {
+	static description = "Updates @platforma-sdk and @milaboratories packages in pnpm-workspace.yaml catalog to their latest versions from npm registry.";
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+	async run() {
+		let e = S(import.meta.url).resolve("@platforma-sdk/blocks-deps-updater/scripts/updater.js");
+		x(process.execPath, [e], {
+			stdio: "inherit",
+			cwd: process.cwd()
+		});
+	}
 };
-export {
-  Ne as COMMANDS
+const R = {
+	"build-meta": C,
+	"build-model": T,
+	"list-overview-snapshots": E,
+	"mark-stable": D,
+	pack: O,
+	publish: A,
+	"refresh-registry": j,
+	"restore-overview-from-snapshot": M,
+	"upload-package-v1": I,
+	"update-deps": L
 };
-//# sourceMappingURL=cli.mjs.map
+export { R as COMMANDS };
+
+//# sourceMappingURL=cli.mjs.map