@microtronics/studio-cli 0.29.4 → 0.31.0

package/CHANGELOG.md

@@ -1,10 +1,35 @@
 
 
-## 0.29.4 (2025-04-25)
+## 0.31.0 (2025-05-05)
 
 
-### Bug Fixes
+### Features
 
+* replace tarballjs with @gera2ld/tarjs ([b32454e](https://bitbucket.org/microtronics-core/vscode-studio/commits/b32454e04a5cd8f21ebb1e91f75fbe062fc593d8))
+* **studio-cli:** add package path autodetection with "*" ([868b035](https://bitbucket.org/microtronics-core/vscode-studio/commits/868b03564dc9e3b31eb279d72826b17f1333503b))
+* **studio-cli:** add support for publishing from archive ([79ef977](https://bitbucket.org/microtronics-core/vscode-studio/commits/79ef97783a56ce440e53e82dabd621db65c54637))
+* **studio-cli:** support library publishing from package ([c731637](https://bitbucket.org/microtronics-core/vscode-studio/commits/c731637960a4de698eec5447005287a16b4cf73a))
+
+## 0.30.0 (2025-05-05)
+
+
+### Features
+
+* **studio-cli:** add support for packaging app projects ([280115f](https://bitbucket.org/microtronics-core/vscode-studio/commits/280115fa77afb78754884a4eb83bd0365ff5b319))
+* **studio-cli:** add support for packaging library projects ([1888df1](https://bitbucket.org/microtronics-core/vscode-studio/commits/1888df1b5d8c2f53a9705756d28d42360109e3ba))
+
+
+### Bug Fixes
+
+* **studio-cli:** ensure dist/dlo directory is created on compile ([f110636](https://bitbucket.org/microtronics-core/vscode-studio/commits/f110636fc5042a5e25cc2d26fc98df4356d706bb))
+* **studio-cli:** rename method in CustomWasmFS ([c3e1a22](https://bitbucket.org/microtronics-core/vscode-studio/commits/c3e1a227d7e57e91f9ddea45f11412ed59f71614))
+* **studio-cli:** run dlo compiler relative to the cwd ([110b476](https://bitbucket.org/microtronics-core/vscode-studio/commits/110b4767bda8134aca2781c51f6e06bf800c4c67))
+
+## 0.29.4 (2025-04-25)
+
+
+### Bug Fixes
+
 * **studio-cli:** always use a clean app version as reference for dde generation ([da0b45b](https://bitbucket.org/microtronics-core/vscode-studio/commits/da0b45b5d9482056b3ead821e5b20e4083f4f06e))
 
 ## 0.29.3 (2025-04-25)

package/dist/studio-cli.d.ts

@@ -1807,48 +1807,17 @@ declare class DloCompiler {
     private cwd;
     private fs;
     private logger;
-    private preCompiler;
     private dloCC;
     private stdout;
     private stderr;
     constructor(cwd: URI, fs: LocalFS, logger: Log.Logger);
     private initDloCC;
-    private get MEMFS();
     compile(cwd: URI, fs: LocalFS): Promise<{
         code: number;
         stdout: string[];
         stderr: string[];
         diagnostics: Diagnostics.File[];
     }>;
-    private persistGeneratedFiles;
-    /**
-     * Search for all dlo files and persist it to the MEMFS
-     * @param cwd
-     * @param fs
-     * @param manifest
-     * @private
-     */
-    /**
-     * Precompile the given file and pass it to the MEMFS
-     * @param cwd
-     * @param manifest
-     * @param file
-     * @param stringBlob
-     */
-    memFSwriteFile(cwd: URI, manifest: Manifest.Manifest, file: URI, stringBlob: string[]): Promise<Diagnostics.File[]>;
-    /**
-     * Move a file within the MEMFS
-     * @param oldUri
-     * @param newUri
-     */
-    memFSmove(oldUri: URI, newUri: URI): Promise<void>;
-    /**
-     * Remove a file from the MEMFS
-     * @param uri
-     */
-    memFSunlink(uri: URI): Promise<void>;
-    private memFSmkdir;
-    private memFSstat;
     /**
      * Get a symbol compiler instance
      */
@@ -2101,7 +2070,7 @@ export declare namespace Library {
      * @param archive
      * @param env
      */
-    export function publishPackage(cwd: URI, fs: LocalFS, token: Registry.AuthToken, archive: Uint8Array, env?: Globals.ENV): Promise<void>;
+    export function publishPackage(token: Registry.AuthToken, manifest: Manifest.Manifest, archive: Uint8Array, env?: Globals.ENV): Promise<void>;
 }
 
 declare interface LocalFS {
@@ -2146,6 +2115,12 @@ declare interface LocalFS {
      * @param target The destination location.
      */
     copy: (source: URI, target: URI) => Promise<any>;
+    /**
+     * Create a new directory
+     *
+     * @param path The directory path that should be created.
+     */
+    mkdir: (path: URI) => Promise<any>;
 }
 
 export declare namespace Log {
@@ -2319,6 +2294,19 @@ export declare namespace Manifest {
     export function isApmPartEnabled(cwd: URI, fs: LocalFS, apmPart: APM.Part, manifest?: Manifest.Manifest): Promise<boolean>;
 }
 
+/**
+ * Packs the given directory into a deployable package using the specified configuration.
+ *
+ * @param {URI} cwd - The current working directory URI where the package is located.
+ * @param {LocalFS} fs - The file system interface to perform file-related operations.
+ * @param {Log.Logger} logger - The logger instance for logging activity during the packaging process.
+ * @param {Globals.ENV} env - The environment variables and settings to use during packaging.
+ * @param {string | null} apiToken - The API token used for authentication, if required.
+ * @param {APM.TagPhase} [optsPhase] - An optional tag phase for the package tagging process.
+ * @return {Promise<Package>} A promise that resolves to the packaged result.
+ */
+export declare function pack(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Globals.ENV, apiToken: string | null, optsPhase?: APM.TagPhase): Promise<void>;
+
 export declare namespace Package {
     export interface MergedDiagnostics {
         [APM.Part.dde]: Diagnostics.File[];
@@ -2350,6 +2338,7 @@ export declare namespace Package {
      * @param env
      */
     export function release(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Globals.ENV, token: Registry.AuthToken, releasePhase?: APM.TagPhase, allowedBackends?: Registry.ApiNewApplication['allowedBackends']): Promise<void>;
+    export function pack(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Globals.ENV, token: Registry.AuthToken, releasePhase?: APM.TagPhase): Promise<void>;
     /**
      * Publish an application model tag
      * @param cwd
@@ -2370,6 +2359,21 @@ export declare namespace Package {
      * @param env
      */
     export function releaseLibrary(cwd: URI, fs: LocalFS, logger: Log.Logger, token: Registry.AuthToken, env: Globals.ENV): Promise<void>;
+    /**
+     * Publishes an archive package to the appropriate library or application registry.
+     *
+     * @param {URI} cwd - The current working directory where the package archive is located.
+     * @param {LocalFS} fs - The file system interface for reading and writing files.
+     * @param {Log.Logger} logger - The logger instance for logging messages during the operation.
+     * @param {Registry.AuthToken} token - The authorization token required for interacting with the registry.
+     * @param {Globals.ENV} env - The global environment settings.
+     * @param {string} packagePath - The relative path to the archive package to be published.
+     * @param {APM.TagPhase} [releasePhase] - An optional release phase for tagging the published version of the application.
+     * @param {Registry.ApiNewApplication['allowedBackends']} [allowedBackends] - An optional list of allowed backends for the published version.
+     *
+     * @return {Promise<void>} A promise that resolves when the publication process completes successfully.
+     */
+    export function publishArchive(cwd: URI, fs: LocalFS, logger: Log.Logger, token: Registry.AuthToken, env: Globals.ENV, packagePath: string, releasePhase?: APM.TagPhase, allowedBackends?: Registry.ApiNewApplication['allowedBackends']): Promise<void>;
     /**
      * Read the projects README.md file
      * validates if the file content is the initial content
@@ -2393,9 +2397,12 @@ export declare namespace Package {
      * @param env
      */
     export function validatePublishSettings(cwd: URI, fs: LocalFS, token: Registry.AuthToken, env: Globals.ENV): Promise<void>;
+    export function readFilesFromTarGz(gzipped: Uint8Array, fileNames: string[]): Promise<{
+        [key: string]: Blob;
+    }>;
 }
 
-declare function parseWarningsAndErrors(stderr: string[], relatedFile?: URI): Diagnostics.File[];
+declare function parseWarningsAndErrors(cwd: URI, stderr: string[], relatedFile?: URI): Diagnostics.File[];
 
 /**
  * This file was auto-generated by openapi-typescript.
@@ -4614,9 +4621,10 @@ declare interface paths {
  * @param {string | null} apiToken - The API token for authentication, or null if not applicable.
  * @param {string | undefined} optsAllowedBackends - A semicolon-separated list of allowed backends, or '*' to allow all, or undefined if not specified.
  * @param {APM.TagPhase} optsPhase - The release phase tag associated with the package publishing.
+ * @param {string }packagePath - The path to the package to be published. If not provided, the package will be published using the default settings.
  * @return {Promise<void>} A promise that resolves when the package has been successfully published or rejects with an error if the process fails.
  */
-export declare function publish(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Globals.ENV, apiToken: string | null, optsAllowedBackends: string | undefined, optsPhase?: APM.TagPhase): Promise<void>;
+export declare function publish(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Globals.ENV, apiToken: string | null, optsAllowedBackends: string | undefined, optsPhase?: APM.TagPhase, packagePath?: string): Promise<void>;
 
 export declare namespace Registry {
     export type AuthToken = string | null;

package/out/api.js

@@ -4,6 +4,7 @@ exports.Log = exports.ENV = exports.DFILES = exports.Library = exports.APM = exp
 exports.install = install;
 exports.build = build;
 exports.publish = publish;
+exports.pack = pack;
 const dependencies_1 = require("./dependencies");
 Object.defineProperty(exports, "Dependencies", { enumerable: true, get: function () { return dependencies_1.Dependencies; } });
 const manifest_1 = require("./manifest");
@@ -79,6 +80,26 @@ async function install(cwd, fs, env, apiToken, dependencies) {
 async function build(cwd, fs, logger, env, apiToken = null, selectedParts = true, errorWithDiagnostics) {
     return package_1.Package.buildAll(cwd, fs, logger, env, apiToken, selectedParts, errorWithDiagnostics);
 }
+/**
+ * Parses and validates the allowed backends configuration.
+ *
+ * @param {string | undefined} optsAllowedBackends - A string defining allowed backends,
+ * either as a semicolon-separated list of backends or the wildcard '*'. It may also be undefined.
+ * @return {Promise<Registry.ApiNewApplication['allowedBackends']>} A promise that resolves to
+ * an array of allowed backends or null if none are provided.
+ * @throws {Error} Throws an error if the validation of the allowed backends fails.
+ */
+async function parseAllowedBackends(optsAllowedBackends) {
+    let allowedBackends = null;
+    if (optsAllowedBackends) {
+        allowedBackends = optsAllowedBackends === '*' ? optsAllowedBackends : optsAllowedBackends.split(';');
+        const errorMessage = await manifest_1.Manifest.validateRegistryAllowedBackends(allowedBackends);
+        if (errorMessage) {
+            throw new Error(errorMessage);
+        }
+    }
+    return allowedBackends;
+}
 /**
  * Publishes a package to the registry with the specified settings and configurations.
  *
@@ -89,18 +110,32 @@ async function build(cwd, fs, logger, env, apiToken = null, selectedParts = true
  * @param {string | null} apiToken - The API token for authentication, or null if not applicable.
  * @param {string | undefined} optsAllowedBackends - A semicolon-separated list of allowed backends, or '*' to allow all, or undefined if not specified.
  * @param {APM.TagPhase} optsPhase - The release phase tag associated with the package publishing.
+ * @param {string }packagePath - The path to the package to be published. If not provided, the package will be published using the default settings.
  * @return {Promise<void>} A promise that resolves when the package has been successfully published or rejects with an error if the process fails.
  */
-async function publish(cwd, fs, logger, env, apiToken, optsAllowedBackends, optsPhase) {
+async function publish(cwd, fs, logger, env, apiToken, optsAllowedBackends, optsPhase, packagePath) {
     logger.info('Publishing package...');
-    let allowedBackends = null;
-    if (optsAllowedBackends) {
-        allowedBackends = optsAllowedBackends === '*' ? optsAllowedBackends : optsAllowedBackends.split(';');
-        const errorMessage = await manifest_1.Manifest.validateRegistryAllowedBackends(allowedBackends);
-        if (errorMessage) {
-            throw new Error(errorMessage);
-        }
+    const allowedBackends = await parseAllowedBackends(optsAllowedBackends);
+    if (packagePath) {
+        await package_1.Package.publishArchive(cwd, fs, logger, apiToken, env, packagePath, optsPhase, allowedBackends);
+    }
+    else {
+        await package_1.Package.validatePublishSettings(cwd, fs, apiToken, env);
+        return package_1.Package.release(cwd, fs, logger, env, apiToken, optsPhase, allowedBackends);
     }
-    return package_1.Package.release(cwd, fs, logger, env, apiToken, optsPhase, allowedBackends);
+}
+/**
+ * Packs the given directory into a deployable package using the specified configuration.
+ *
+ * @param {URI} cwd - The current working directory URI where the package is located.
+ * @param {LocalFS} fs - The file system interface to perform file-related operations.
+ * @param {Log.Logger} logger - The logger instance for logging activity during the packaging process.
+ * @param {Globals.ENV} env - The environment variables and settings to use during packaging.
+ * @param {string | null} apiToken - The API token used for authentication, if required.
+ * @param {APM.TagPhase} [optsPhase] - An optional tag phase for the package tagging process.
+ * @return {Promise<Package>} A promise that resolves to the packaged result.
+ */
+async function pack(cwd, fs, logger, env, apiToken, optsPhase) {
+    return package_1.Package.pack(cwd, fs, logger, env, apiToken, optsPhase);
 }
 //# sourceMappingURL=api.js.map

package/out/cliFS.js

@@ -66,6 +66,9 @@ exports.cliFS = {
         else {
             return promises_1.default.copyFile(source.fsPath, target.fsPath);
         }
+    },
+    async mkdir(path) {
+        await promises_1.default.mkdir(path.fsPath, { recursive: true });
     }
 };
 //# sourceMappingURL=cliFS.js.map

package/out/dlo/CustomWasmFS.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CUSTOM_WASM_FS = exports.precompilerDiagnostics = void 0;
 exports.uriToMemFsPath = uriToMemFsPath;
+exports.relativeMemFsPath = relativeMemFsPath;
 const nodeFs = __importStar(require("fs"));
 const vscode_uri_1 = require("vscode-uri");
 const preCompiler_1 = require("./preCompiler");
@@ -62,6 +63,25 @@ const CUSTOM_WASM_FS = (FS, cwd, manifest) => {
                 ctime: stat.ctime
             };
         },
+        setattr(node, attr) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(node.mount.opts.root), FS.getPath(node)).fsPath;
+            if (!nodeFs.existsSync(path)) {
+                throw new FS.ErrnoError(44 /* ENOENT */);
+            }
+            // Change file size (truncate/grow)
+            if (typeof attr.size === 'number') {
+                nodeFs.truncateSync(path, attr.size);
+            }
+            // Change file mode (permissions)
+            if (typeof attr.mode === 'number') {
+                nodeFs.chmodSync(path, attr.mode);
+            }
+            // Change access/modification time
+            if (attr.atime || attr.mtime) {
+                const stat = nodeFs.statSync(path);
+                nodeFs.utimesSync(path, attr.atime ?? stat.atime, attr.mtime ?? stat.mtime);
+            }
+        },
         lookup(parent, name) {
             const currPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name);
             const path = currPath.fsPath;
@@ -81,7 +101,10 @@ const CUSTOM_WASM_FS = (FS, cwd, manifest) => {
         mknod(parent, name, mode, dev) {
             const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
             nodeFs.writeFileSync(path, '');
-            return FS.createNode(parent, name, mode, dev);
+            const node = FS.createNode(parent, name, mode, dev);
+            node.node_ops = parent.node_ops;
+            node.stream_ops = parent.stream_ops;
+            return node;
         },
         unlink(parent, name) {
             const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
@@ -90,14 +113,17 @@ const CUSTOM_WASM_FS = (FS, cwd, manifest) => {
         mkdir(parent, name, mode) {
             const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
             nodeFs.mkdirSync(path, { mode });
-            return FS.createNode(parent, name, mode | MODE_DIR, 0);
+            const node = FS.createNode(parent, name, mode | MODE_DIR, 0);
+            node.node_ops = parent.node_ops;
+            node.stream_ops = parent.stream_ops;
+            return node;
         },
         rmdir(parent, name) {
             const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
             nodeFs.rmdirSync(path);
         },
-        rename(oldParent, oldName, newParent, newName) {
-            const oldPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(oldParent.mount.opts.root), FS.getPath(oldParent), oldName).fsPath;
+        rename(oldParent, newParent, newName) {
+            const oldPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(oldParent.mount.opts.root), FS.getPath(oldParent)).fsPath;
             const newPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(newParent.mount.opts.root), FS.getPath(newParent), newName).fsPath;
             nodeFs.renameSync(oldPath, newPath);
         }
@@ -224,4 +250,9 @@ function precompileRequestedDloFile(cwd, manifest, filePath) {
 function uriToMemFsPath(path) {
     return path.fsPath.replace(/\\/g, '/');
 }
+function relativeMemFsPath(cwd, path) {
+    const cwdPath = uriToMemFsPath(cwd);
+    const fsPath = uriToMemFsPath(path);
+    return fsPath.replace(cwdPath, '');
+}
 //# sourceMappingURL=CustomWasmFS.js.map

package/out/dlo/compiler.js

@@ -1,37 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DloCompiler = void 0;
 exports.parseWarningsAndErrors = parseWarningsAndErrors;
 exports.generateConfigFile = generateConfigFile;
-const preCompiler_1 = require("./preCompiler");
 const vscode_uri_1 = require("vscode-uri");
 const manifest_1 = require("../manifest");
 const defaultFiles_1 = require("../defaultFiles");
 const dependencies_1 = require("../dependencies");
-const iconv = __importStar(require("iconv-lite"));
 const apm_1 = require("../package/apm");
 const CustomWasmFS_1 = require("./CustomWasmFS");
 const DLO_MODULE = require('./dlocc.js');
@@ -39,7 +14,6 @@ class DloCompiler {
     cwd;
     fs;
     logger;
-    preCompiler = new preCompiler_1.DloPreCompiler();
     dloCC;
     stdout = [];
     stderr = [];
@@ -55,16 +29,18 @@ class DloCompiler {
         this.dloCC = await DLO_MODULE({
             noExitRuntime: noExit,
             print: (data) => {
-                this.logger.log(data);
+                const patched = parseCompilerMessage(this.cwd, data);
+                this.logger.log(patched ? patched.message : data);
                 this.stdout.push(data);
             },
             printErr: (err) => {
+                const patched = parseCompilerMessage(this.cwd, err);
                 // filter for warn messages
                 if (err.includes(': warning')) {
-                    this.logger.warn(err);
+                    this.logger.warn(patched ? patched.message : err);
                 }
                 else {
-                    this.logger.error(err);
+                    this.logger.error(patched ? patched.message : err);
                 }
                 this.stderr.push(err);
                 this.stdout.push(err);
@@ -78,9 +54,8 @@ class DloCompiler {
         FS.filesystems.NODEFS_TS = (0, CustomWasmFS_1.CUSTOM_WASM_FS)(FS, this.cwd, manifest);
         FS.mkdir(rootDir);
         FS.mount(FS.filesystems.NODEFS_TS, { root: '/' }, rootDir);
-    }
-    get MEMFS() {
-        return this.dloCC.FS;
+        // Set the current working directory to the root directory
+        FS.chdir((0, CustomWasmFS_1.uriToMemFsPath)(this.cwd));
     }
     async compile(cwd, fs) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
@@ -94,18 +69,17 @@ class DloCompiler {
             };
         }
         await this.initDloCC();
+        await fs.mkdir(vscode_uri_1.Utils.joinPath(cwd, 'dist/dlo'));
         const mainFile = vscode_uri_1.Utils.joinPath(cwd, manifest.dlo?.mainFile || defaultFiles_1.DefaultFiles.filePaths.dlo.mainDLO);
         const options = [];
         // read config file
         const configFilePath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg);
-        options.push(`-T${(0, CustomWasmFS_1.uriToMemFsPath)(configFilePath)}`);
+        const configFile = (0, CustomWasmFS_1.relativeMemFsPath)(cwd, configFilePath);
+        options.push(`-T.${configFile}`);
         let exitCode = 0;
         try {
-            exitCode = await this.dloCC.callMain([(0, CustomWasmFS_1.uriToMemFsPath)(mainFile), ...options]);
-            // compiler doesn't have any errors
-            if (exitCode === 0) {
-                await this.persistGeneratedFiles(cwd, fs, mainFile);
-            }
+            const mainFilePath = `.${(0, CustomWasmFS_1.relativeMemFsPath)(cwd, mainFile)}`;
+            exitCode = await this.dloCC.callMain([mainFilePath, ...options]);
         }
         catch (e) {
             this.logger.error(e);
@@ -114,109 +88,9 @@ class DloCompiler {
             code: exitCode,
             stdout: this.stdout,
             stderr: this.stderr,
-            diagnostics: [...CustomWasmFS_1.precompilerDiagnostics, ...parseWarningsAndErrors(this.stderr, mainFile)]
+            diagnostics: [...CustomWasmFS_1.precompilerDiagnostics, ...parseWarningsAndErrors(cwd, this.stderr, mainFile)]
         };
     }
-    async persistGeneratedFiles(cwd, fs, mainFile) {
-        const baseName = vscode_uri_1.Utils.basename(mainFile).split('.')[0];
-        const possibleFiles = this.MEMFS.readdir('/');
-        for (const fileName of possibleFiles) {
-            if (fileName.startsWith(baseName)) {
-                const blob = this.MEMFS.readFile(fileName);
-                const distPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.dloPath, fileName);
-                await fs.writeFile(distPath, blob);
-            }
-        }
-    }
-    /**
-     * Search for all dlo files and persist it to the MEMFS
-     * @param cwd
-     * @param fs
-     * @param manifest
-     * @private
-     */
-    /*	private async persistDloFiles(cwd: URI, fs: LocalFS, manifest: Manifest.Manifest) {
-        const files = await fs.findFiles(cwd, '**!/!*.{dlo,inc}');
-        const precompilerDiagnostics: Diagnostics.File[] = [];
-        // add dlo.cfg file to the file list
-        for (const file of files) {
-            if (await fs.stat(file)) {
-                const content = await fs.readFile(file);
-                const stringBlob = convertBlobToStringArray(content);
-                const diagnostics = await this.memFSwriteFile(cwd, manifest, file, stringBlob);
-                precompilerDiagnostics.push(...diagnostics);
-            }
-        }
-        return precompilerDiagnostics;
-    }*/
-    /**
-     * Precompile the given file and pass it to the MEMFS
-     * @param cwd
-     * @param manifest
-     * @param file
-     * @param stringBlob
-     */
-    async memFSwriteFile(cwd, manifest, file, stringBlob) {
-        const precompilerDiagnostics = [];
-        const preCompiled = this.preCompiler.preCompileDloFile(cwd, manifest, file, stringBlob);
-        precompilerDiagnostics.push(...preCompiled.diagnostics);
-        this.memFSmkdir(file);
-        this.MEMFS.writeFile((0, CustomWasmFS_1.uriToMemFsPath)(file), iconv.encode(preCompiled.data, 'cp1252'));
-        return precompilerDiagnostics;
-    }
-    /**
-     * Move a file within the MEMFS
-     * @param oldUri
-     * @param newUri
-     */
-    async memFSmove(oldUri, newUri) {
-        try {
-            this.memFSmkdir(newUri);
-            this.MEMFS.rename((0, CustomWasmFS_1.uriToMemFsPath)(oldUri), (0, CustomWasmFS_1.uriToMemFsPath)(newUri));
-        }
-        catch (e) {
-            this.logger.error('memFSmove', e);
-        }
-    }
-    /**
-     * Remove a file from the MEMFS
-     * @param uri
-     */
-    async memFSunlink(uri) {
-        try {
-            this.MEMFS.unlink((0, CustomWasmFS_1.uriToMemFsPath)(uri));
-        }
-        catch (e) {
-            this.logger.error('memFSunlink', e);
-        }
-    }
-    memFSmkdir(uri) {
-        const split = (0, CustomWasmFS_1.uriToMemFsPath)(vscode_uri_1.Utils.dirname(uri)).split('/');
-        let dirname = '';
-        split.forEach(folder => {
-            if (!folder) {
-                return;
-            }
-            try {
-                dirname += `${folder}/`;
-                if (!this.memFSstat(dirname)) {
-                    this.MEMFS.mkdir(dirname);
-                }
-            }
-            catch (e) {
-                this.logger.error('memFSmkdir', e);
-            }
-        });
-    }
-    memFSstat(dirname) {
-        try {
-            this.MEMFS.stat(dirname);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
     //Symbol Compiler handling
     /**
      * Get a symbol compiler instance
@@ -253,7 +127,7 @@ class DloCompiler {
     }
 }
 exports.DloCompiler = DloCompiler;
-function parseWarningsAndErrors(stderr, relatedFile) {
+function parseWarningsAndErrors(cwd, stderr, relatedFile) {
     const compilerDiagnostics = [];
     const messages = stderr.filter(line => !!line.trim());
     for (const message of messages) {
@@ -266,35 +140,44 @@ function parseWarningsAndErrors(stderr, relatedFile) {
             });
             continue;
         }
-        // regular error/warning - such as:
-        // 		C:\Users\aai\rmstudio\apmparts\dlo-pawn\stdlib\rm-dde.inc(392) : error 036: empty statement
-        // 		main.p(138) : warning 203: symbol is never used: "log_str"
-        //		main.p(6) : fatal error 100: cannot read from file: "oTests/module_t"
-        const i0 = message.indexOf(' : ');
-        const i1 = message.indexOf(': ', i0 + 3);
-        const fileNameAndLineNumber = message.substring(0, i0).trim();
-        const levelAndCode = message.substring(i0 + 3, i1).trim();
-        const msg = message.substring(i1 + 2).trim();
-        // ignore lines which do not contain err/warn msg (or are empty)
-        if (!fileNameAndLineNumber || !levelAndCode || !msg) {
+        const parsedMessage = parseCompilerMessage(cwd, message);
+        if (!parsedMessage) {
             continue;
         }
-        const [fileName, lineNumber] = fileNameAndLineNumber.split(/[()(-)]/);
-        const decodeLevelAndCode = levelAndCode.split(' ');
-        const level = decodeLevelAndCode[decodeLevelAndCode.length - 2]; //lvl is always the second last
-        let posix = fileName.replace(/\\/g, '/');
-        if (posix.startsWith('/')) {
-            posix = posix.substring(1);
-        }
         compilerDiagnostics.push({
-            file: vscode_uri_1.URI.parse(`file:///${posix}`),
-            level,
-            line: Number(lineNumber) - 1,
-            message: msg
+            file: vscode_uri_1.URI.parse(`file:///${parsedMessage?.posixPath}`),
+            level: parsedMessage.level,
+            line: Number(parsedMessage.lineNumber) - 1,
+            message: parsedMessage.msg
         });
     }
     return compilerDiagnostics;
 }
+function parseCompilerMessage(cwd, message) {
+    // regular error/warning - such as:
+    // 		C:\Users\aai\rmstudio\apmparts\dlo-pawn\stdlib\rm-dde.inc(392) : error 036: empty statement
+    // 		main.p(138) : warning 203: symbol is never used: "log_str"
+    //		main.p(6) : fatal error 100: cannot read from file: "oTests/module_t"
+    const i0 = message.indexOf(' : ');
+    const i1 = message.indexOf(': ', i0 + 3);
+    const fileNameAndLineNumber = message.substring(0, i0).trim();
+    const levelAndCode = message.substring(i0 + 3, i1).trim();
+    const msg = message.substring(i1 + 2).trim();
+    // ignore lines which do not contain err/warn msg (or are empty)
+    if (!fileNameAndLineNumber || !levelAndCode || !msg) {
+        return null;
+    }
+    const [fileName, lineNumber] = fileNameAndLineNumber.split(/[()(-)]/);
+    const decodeLevelAndCode = levelAndCode.split(' ');
+    const level = decodeLevelAndCode[decodeLevelAndCode.length - 2]; //lvl is always the second last
+    const filePath = vscode_uri_1.Utils.joinPath(cwd, fileName);
+    let posixPath = filePath.fsPath.replace(/\\/g, '/');
+    if (posixPath.startsWith('/')) {
+        posixPath = posixPath.substring(1);
+    }
+    const patchedMessage = message.replace(fileName, posixPath);
+    return { level, msg, posixPath, lineNumber, message: patchedMessage };
+}
 /**
  * Generates the DLO .cfg file for the dlo compiler
  * @param cwd
@@ -307,16 +190,17 @@ async function generateConfigFile(cwd, fs, manifest) {
         '-v2' // verbosity of stdout -> 0=quiet, 1=normal, 2=code/data/stack usage report
     ];
     const defaultIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.defaultInc);
-    compileOptions.push(`-p${(0, CustomWasmFS_1.uriToMemFsPath)(defaultIncPath)}`);
+    compileOptions.push(`-p.${(0, CustomWasmFS_1.relativeMemFsPath)(cwd, defaultIncPath)}`);
     const dloLibs = await dependencies_1.Dependencies.getApmPartDependencies(cwd, fs, apm_1.APM.Part.dlo);
     for (const dloLib of dloLibs) {
         const dirName = vscode_uri_1.Utils.dirname(dloLib.path);
-        compileOptions.push(`-i${(0, CustomWasmFS_1.uriToMemFsPath)(dirName)}`);
+        compileOptions.push(`-i.${(0, CustomWasmFS_1.relativeMemFsPath)(cwd, dirName)}`);
     }
     const dloConfiguration = manifest.dlo;
     if (dloConfiguration) {
         compileOptions.push(...dloConfiguration.compileOptions);
     }
+    compileOptions.push(`-o./dist/dlo/main.amx`);
     return {
         path: vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg),
         data: compileOptions.join('\n')

package/out/main.js

@@ -69,6 +69,23 @@ const optionStudioEnv = new commander_1.Option('-e, --env <environment>', 'CLI t
  * Generic option for the STUDIO_TOKEN
  */
 const optionStudioToken = new commander_1.Option('--token <API-token>', 'API Access Token (defaults to STUDIO_TOKEN environment variable)').default(process.env['STUDIO_TOKEN']);
+/**
+ * Represents a command-line option for specifying the allowed backends deployment for a version.
+ *
+ * This variable represents an instance of an `Option` that determines which backends are permitted
+ * during the deployment process. The backends can be specified as*/
+const optionAllowedBackends = new commander_1.Option('--allowedBackends <null|*|server.xz;server.yz>', 'specify the allowedBackends deployment for this version.').default(null);
+const releasePhaseArguments = Object.values(apm_1.APM.TagPhase);
+/**
+ * Represents a command-line option for specifying a release phase in a software deployment process.
+ *
+ * The option includes a flag `-ph` or `--phase`, followed by the user-defined release phase value. It offers predefined
+ * choices for acceptable release phase arguments, ensuring input validation. If no value is explicitly provided,
+ * the default release phase is set to 'release'.
+ */
+const optionReleasePhase = new commander_1.Option('-ph --phase <release phase>', 'specify a release phase')
+    .choices(releasePhaseArguments)
+    .default('release');
 program
     .command('install')
     .aliases(['i'])
@@ -91,18 +108,27 @@ program
     const { env, token } = getDefaultOptions(opts);
     main((0, api_1.build)(cwd, cliFS_1.cliFS, logger, env, token, opts.part));
 });
-const releasePhaseArguments = Object.values(apm_1.APM.TagPhase);
 program
     .command('publish')
-    .addOption(new commander_1.Option('-ph --phase <release phase>', 'specify a release phase')
-    .choices(releasePhaseArguments)
-    .default('release'))
-    .addOption(new commander_1.Option('--allowedBackends <null|*|server.xz;server.yz>', 'specify the allowedBackends deployment for this version.').default(null))
+    .addOption(optionReleasePhase)
+    .addOption(optionAllowedBackends)
+    .addOption(optionStudioEnv)
+    .addOption(optionStudioToken)
+    .option('-i, --packagePath <path>', 'Publish the provided library or app package. Use "*" for autodetection.')
+    .action(async (opts) => {
+    const { env, token } = getDefaultOptions(opts);
+    main((0, api_1.publish)(cwd, cliFS_1.cliFS, logger, env, token, opts.allowedBackends, opts.phase, opts.packagePath));
+});
+program
+    .command('package')
+    .alias('pack')
+    .description('Package the project')
+    .addOption(optionReleasePhase)
     .addOption(optionStudioEnv)
     .addOption(optionStudioToken)
     .action(async (opts) => {
     const { env, token } = getDefaultOptions(opts);
-    main((0, api_1.publish)(cwd, cliFS_1.cliFS, logger, env, token, opts.allowedBackends, opts.phase));
+    main((0, api_1.pack)(cwd, cliFS_1.cliFS, logger, env, token, opts.phase));
 });
 module.exports = function (argv) {
     program.parse(argv);

package/out/package/library.js

@@ -6,11 +6,10 @@ const helper_1 = require("../helper");
 var convertBlobToString = helper_1.Helper.convertBlobToString;
 const minimatch_1 = require("minimatch");
 const registryAPI_1 = require("../registryAPI");
-const manifest_1 = require("../manifest");
 const package_1 = require("./package");
 const globals_1 = require("../globals");
+const tarjs_1 = require("@gera2ld/tarjs");
 const pako = require('pako');
-const tarball = require('tarballjs');
 const STUDIO_IGNORE_FILE = '.studioignore';
 //see original list: https://github.com/microsoft/vscode-vsce/blob/main/src/package.ts#L1603
 const defaultIgnore = [
@@ -57,13 +56,13 @@ var Library;
      * @param fs
      */
     async function createArchive(cwd, fs) {
-        const tar = new tarball.TarWriter();
+        const tar = new tarjs_1.TarWriter();
         const filesToPack = await getFilesForArchive(cwd, fs);
         filesToPack.forEach(file => {
-            tar.addFileArrayBuffer(file.name, file.data);
+            tar.addFile(file.name, file.data);
         });
         const tarBuffer = await tar.write();
-        return pako.gzip(tarBuffer);
+        return pako.gzip(await tarBuffer.arrayBuffer());
     }
     Library.createArchive = createArchive;
     /**
@@ -102,13 +101,14 @@ var Library;
      * @param archive
      * @param env
      */
-    async function publishPackage(cwd, fs, token, archive, env = globals_1.Globals.ENV.production) {
-        const { publisher, name, version } = await manifest_1.Manifest.read(cwd, fs);
+    async function publishPackage(token, manifest, archive, env = globals_1.Globals.ENV.production) {
+        const { publisher, name, version } = manifest;
+        const extractedFiles = await package_1.Package.readFilesFromTarGz(archive, ['CHANGELOG.md', 'README.md', 'studio.json']);
         const files = {
-            'CHANGELOG.md': await package_1.Package.getChangelogFile(cwd, fs),
-            'README.md': await package_1.Package.getReadmeFile(cwd, fs, name),
-            'library.tar.gz': archive,
-            'studio.json': await manifest_1.Manifest.readAsBlob(cwd, fs)
+            'CHANGELOG.md': await blobToUint8Array(extractedFiles['CHANGELOG.md']),
+            'README.md': await blobToUint8Array(extractedFiles['README.md']),
+            'studio.json': await blobToUint8Array(extractedFiles['studio.json']),
+            'library.tar.gz': archive
         };
         return await registryAPI_1.Registry.publishLibraryVersion(token, publisher, name, version, files, env);
     }
@@ -159,4 +159,7 @@ async function getIgnoreFile(cwd, fs) {
         return '';
     }
 }
+async function blobToUint8Array(blob) {
+    return new Uint8Array(await blob.arrayBuffer());
+}
 //# sourceMappingURL=library.js.map

package/out/package/package.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Package = void 0;
+exports.readManifestFromArchive = readManifestFromArchive;
 const vscode_uri_1 = require("vscode-uri");
 const helper_1 = require("../helper");
 const defaultFiles_1 = require("../defaultFiles");
@@ -14,6 +15,8 @@ const registryAPI_1 = require("../registryAPI");
 const manifest_1 = require("../manifest");
 const library_1 = require("./library");
 const dfiles_1 = require("../dfiles/dfiles");
+const tarjs_1 = require("@gera2ld/tarjs");
+const pako = require('pako');
 var Package;
 (function (Package) {
     class BuildError extends Error {
@@ -114,6 +117,29 @@ var Package;
         }
     }
     Package.release = release;
+    async function pack(cwd, fs, logger, env, token, releasePhase) {
+        const manifest = await manifest_1.Manifest.read(cwd, fs);
+        const archiveName = `${manifest.name}-${manifest.version}.tar.gz`;
+        let archive = null;
+        if (manifest_1.Manifest.isLibrary(manifest)) {
+            logger.info('Library project detected. Packing library...');
+            archive = await createLibraryPackage(cwd, fs, logger, token, env);
+        }
+        else {
+            logger.info('App project detected. Packing app...');
+            const apmTag = await createAPMPackage(cwd, fs, logger, token, releasePhase, env);
+            archive = await createArchiveFromApmPackage(apmTag);
+        }
+        const archivePath = vscode_uri_1.Utils.joinPath(cwd, archiveName);
+        if (archive !== null) {
+            await fs.writeFile(archivePath, archive);
+            logger.done(`Packaged: ${archivePath.fsPath}`);
+        }
+        else {
+            logger.error(`Could not create archive: ${archivePath.fsPath}`);
+        }
+    }
+    Package.pack = pack;
     /**
      * Publish an application model tag
      * @param cwd
@@ -125,19 +151,13 @@ var Package;
      * @param env
      */
     async function releaseAPM(cwd, fs, logger, token, releasePhase, allowedBackends = null, env) {
-        if (!Object.values(apm_1.APM.TagPhase).includes(releasePhase)) {
-            throw new Error(`ReleasePhase: ${releasePhase} is not a valid release phase`);
-        }
-        await manifest_1.Manifest.validateBasicManifest(cwd, fs, null);
         const application = await apm_1.APM.validateAccess(cwd, fs, token, false, env);
         if (!application) {
-            return;
+            throw new Error('Could not validate access to application');
         }
-        // build the complete project
-        await buildAll(cwd, fs, logger, env, token);
+        const tagContent = await createAPMPackage(cwd, fs, logger, token, releasePhase, env);
         // update the store apm with the actual name/description/...
         await apm_1.APM.updateProfile(cwd, fs, token, env);
-        const tagContent = await apm_1.APM.createTag(cwd, fs, releasePhase);
         const newTag = await apm_1.APM.publishTag(cwd, fs, token, tagContent, env);
         if (allowedBackends !== null) {
             const manifest = await manifest_1.Manifest.read(cwd, fs);
@@ -160,15 +180,55 @@ var Package;
      */
     async function releaseLibrary(cwd, fs, logger, token, env) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
-        await manifest_1.Manifest.validateBasicManifest(cwd, fs, manifest);
-        await validatePublishSettings(cwd, fs, token, env);
-        // build the complete project
-        await buildAll(cwd, fs, logger, env, token);
-        const archive = await library_1.Library.createArchive(cwd, fs);
-        await library_1.Library.publishPackage(cwd, fs, token, archive, env);
+        const archive = await createLibraryPackage(cwd, fs, logger, token, env);
+        await library_1.Library.publishPackage(token, manifest, archive, env);
         logger.done(`Library "${manifest.publisher}/${manifest.name}" with version "${manifest.version}" published!`);
     }
     Package.releaseLibrary = releaseLibrary;
+    /**
+     * Publishes an archive package to the appropriate library or application registry.
+     *
+     * @param {URI} cwd - The current working directory where the package archive is located.
+     * @param {LocalFS} fs - The file system interface for reading and writing files.
+     * @param {Log.Logger} logger - The logger instance for logging messages during the operation.
+     * @param {Registry.AuthToken} token - The authorization token required for interacting with the registry.
+     * @param {Globals.ENV} env - The global environment settings.
+     * @param {string} packagePath - The relative path to the archive package to be published.
+     * @param {APM.TagPhase} [releasePhase] - An optional release phase for tagging the published version of the application.
+     * @param {Registry.ApiNewApplication['allowedBackends']} [allowedBackends] - An optional list of allowed backends for the published version.
+     *
+     * @return {Promise<void>} A promise that resolves when the publication process completes successfully.
+     */
+    async function publishArchive(cwd, fs, logger, token, env, packagePath, releasePhase, allowedBackends = null) {
+        if (packagePath === '*') {
+            const localManifest = await manifest_1.Manifest.read(cwd, fs);
+            packagePath = `${localManifest.name}-${localManifest.version}.tar.gz`;
+            logger.info(`Publishing detected archive package "${packagePath}"...`);
+        }
+        const archivePath = vscode_uri_1.Utils.joinPath(cwd, packagePath);
+        if (!(await fs.stat(archivePath))) {
+            throw new Error(`Archive package not found: ${archivePath.fsPath}`);
+        }
+        const archive = await fs.readFile(archivePath);
+        const manifest = await readManifestFromArchive(archive);
+        const { publisher, registry, version } = manifest;
+        // add library publishing.
+        if (manifest_1.Manifest.isLibrary(manifest)) {
+            await library_1.Library.publishPackage(token, manifest, archive, env);
+            logger.done(`Library "${publisher}/${manifest.name}" with version "${manifest.version}" published!`);
+        }
+        else {
+            await registryAPI_1.Registry.updateApplicationFile(token, publisher, registry.id, version, 'app.tar.gz', archive, env);
+            // update the version profile
+            await registryAPI_1.Registry.updateExistingApplicationVersion(token, publisher, registry?.id, version, {
+                allowedBackends: allowedBackends || undefined,
+                phase: releasePhase || undefined
+            }, env);
+            logger.info(`Tag "${version}" with phase "${releasePhase}" shared with ${[...(allowedBackends || '')].join(';')}!`);
+            logger.done(`Tag "${version}" with phase "${releasePhase}" published!`);
+        }
+    }
+    Package.publishArchive = publishArchive;
     /**
      * Read the projects README.md file
      * validates if the file content is the initial content
@@ -247,6 +307,22 @@ var Package;
         }
     }
     Package.validatePublishSettings = validatePublishSettings;
+    async function readFilesFromTarGz(gzipped, fileNames) {
+        // Decompress GZ
+        const tarData = pako.ungzip(gzipped);
+        // Parse TAR with tarballjs
+        const tarReader = await tarjs_1.TarReader.load(tarData);
+        const fileList = {};
+        for (const entry of tarReader.fileInfos) {
+            if (fileNames.includes(entry.name)) {
+                // Return file contents as a Buffer
+                fileList[entry.name] = tarReader.getFileBlob(entry.name);
+            }
+        }
+        // File not found
+        return fileList;
+    }
+    Package.readFilesFromTarGz = readFilesFromTarGz;
 })(Package || (exports.Package = Package = {}));
 /**
  * Normalize the selected parts parameter for building.
@@ -357,4 +433,57 @@ function logDiagnostics(logger, diagnostics) {
         }
     });
 }
+async function createLibraryPackage(cwd, fs, logger, token, env) {
+    const manifest = await manifest_1.Manifest.read(cwd, fs);
+    await manifest_1.Manifest.validateBasicManifest(cwd, fs, manifest);
+    // build the complete project
+    await Package.buildAll(cwd, fs, logger, env, token);
+    return await library_1.Library.createArchive(cwd, fs);
+}
+async function createAPMPackage(cwd, fs, logger, token, releasePhase, env) {
+    if (!Object.values(apm_1.APM.TagPhase).includes(releasePhase)) {
+        throw new Error(`ReleasePhase: ${releasePhase} is not a valid release phase`);
+    }
+    await manifest_1.Manifest.validateBasicManifest(cwd, fs, null);
+    // build the complete project
+    await Package.buildAll(cwd, fs, logger, env, token);
+    return await apm_1.APM.createTag(cwd, fs, releasePhase);
+}
+async function createArchiveFromApmPackage(data) {
+    const tar = new tarjs_1.TarWriter();
+    // @ts-ignore .entries is valid on FormData
+    for (const [name, value] of data.entries()) {
+        if (name === 'tag') {
+            const fileNode = value;
+            tar.addFile(name, fileNode);
+        }
+        else {
+            const fileNode = value;
+            tar.addFile(name, await fileNode.arrayBuffer());
+        }
+    }
+    const tarBuffer = await tar.write();
+    return pako.gzip(await tarBuffer.arrayBuffer());
+}
+async function readManifestFromArchive(archive) {
+    const manifestData = await readFileFromTarGz(archive, ['studio.json', 'src/studio.json']);
+    if (!manifestData) {
+        throw new Error(`Could not find "studio.json" in archive`);
+    }
+    return JSON.parse(await manifestData.text());
+}
+async function readFileFromTarGz(gzipped, possibleFilenames) {
+    // Decompress GZ
+    const tarData = pako.ungzip(gzipped);
+    // Parse TAR with tarballjs
+    const tarReader = await tarjs_1.TarReader.load(tarData);
+    for (const entry of tarReader.fileInfos) {
+        if (possibleFilenames.includes(entry.name)) {
+            // Return file contents as a Buffer
+            return tarReader.getFileBlob(entry.name);
+        }
+    }
+    // File not found
+    return null;
+}
 //# sourceMappingURL=package.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microtronics/studio-cli",
-	"version": "0.29.4",
+	"version": "0.31.0",
 	"description": "Microtronics Studio CLI Tool",
 	"main": "./out/api.js",
 	"typings": "./dist/studio-cli.d.ts",
@@ -41,7 +41,7 @@
 		"openapi-fetch": "^0.13.0",
 		"pako": "^2.1.0",
 		"semver": "^7.6.3",
-		"tarballjs": "github:ankitrohatgi/tarballjs",
+		"@gera2ld/tarjs": "^0.3.1",
 		"tinytar-fix": "^0.1.1",
 		"update-notifier": "^7.3.1",
 		"vscode-uri": "^3.0.8",
@@ -63,9 +63,11 @@
 		"chai": "^4.3.8",
 		"chai-as-promised": "^7.1.2",
 		"cross-env": "^7.0.3",
+		"extract-zip": "^2.0.1",
 		"mocha": "^10.8.2",
 		"mocha-junit-reporter": "^2.2.1",
 		"openapi-typescript": "^7.6.0",
+		"tar": "^7.4.3",
 		"ts-node": "^10.9.2",
 		"typescript": "^5.6.3"
 	},