@open-audio-stack/core 0.1.41 → 0.1.43

package/build/classes/Manager.d.ts

@@ -14,7 +14,7 @@ export declare class Manager extends Base {
     getPackage(slug: string): Package | undefined;
     getReport(): ManagerReport;
     outputReport(): void;
-    listPackages(installed?: boolean): Package[];
+    listPackages(installed?: boolean, showAll?: boolean): Package[];
     removePackage(slug: string): void;
     reset(): void;
     search(query: string): Package[];

package/build/classes/Manager.js

@@ -2,6 +2,8 @@ import { apiJson } from '../helpers/api.js';
 import { Config } from './Config.js';
 import { Package } from './Package.js';
 import { Base } from './Base.js';
+import { packageCompatibleFiles } from '../helpers/package.js';
+import { getArchitecture, getSystem } from '../helpers/utilsLocal.js';
 export class Manager extends Base {
     config;
     packages;
@@ -52,19 +54,21 @@ export class Manager extends Base {
             }
         }
     }
-    listPackages(installed) {
+    listPackages(installed, showAll = false) {
+        let packages = Array.from(this.packages.values());
         if (installed !== undefined) {
-            const packagesFiltered = [];
-            Array.from(this.packages.values()).forEach(pkg => {
-                Array.from(pkg.versions.values()).forEach(pkgVersion => {
-                    if ((installed === true && pkgVersion.installed) || (installed === false && !pkgVersion.installed)) {
-                        packagesFiltered.push(pkg);
-                    }
-                });
+            packages = packages.filter(pkg => Array.from(pkg.versions.values()).some(pkgVersion => (installed === true && pkgVersion.installed) || (installed === false && !pkgVersion.installed)));
+        }
+        if (!showAll) {
+            packages = packages.filter(pkg => {
+                const pkgVersion = pkg.getVersionLatest();
+                if (!pkgVersion)
+                    return false;
+                const files = packageCompatibleFiles(pkgVersion, [getArchitecture()], [getSystem()], []);
+                return files.length > 0;
             });
-            return packagesFiltered;
         }
-        return Array.from(this.packages.values());
+        return packages.sort((a, b) => a.slug.localeCompare(b.slug));
     }
     removePackage(slug) {
         if (!this.packages.has(slug))

package/build/classes/ManagerLocal.d.ts

@@ -10,12 +10,12 @@ export declare class ManagerLocal extends Manager {
     create(): Promise<void>;
     scan(ext?: string, installable?: boolean): void;
     export(dir: string, ext?: string): boolean;
-    install(slug: string, version?: string): Promise<void | PackageVersion>;
+    install(slug: string, version?: string): Promise<PackageVersion>;
     installAll(): Promise<Package[]>;
     installDependency(slug: string, version?: string, filePath?: string, type?: RegistryType): Promise<any>;
     installDependencies(filePath: string, type?: RegistryType): Promise<any>;
     open(slug: string, version?: string, options?: string[]): boolean;
-    uninstall(slug: string, version?: string): Promise<void | PackageVersion>;
+    uninstall(slug: string, version?: string): Promise<PackageVersion>;
     uninstallDependency(slug: string, version?: string, filePath?: string, type?: RegistryType): Promise<any>;
     uninstallDependencies(filePath?: string, type?: RegistryType): Promise<any>;
 }

package/build/classes/ManagerLocal.js

@@ -58,7 +58,10 @@ export class ManagerLocal extends Manager {
         ];
         const pkgAnswers = await inquirer.prompt(pkgQuestions);
         let types = pluginTypes;
-        if (this.type === RegistryType.Presets) {
+        if (this.type === RegistryType.Apps) {
+            types = pluginTypes;
+        }
+        else if (this.type === RegistryType.Presets) {
             types = presetTypes;
         }
         else if (this.type === RegistryType.Projects) {
@@ -161,16 +164,28 @@ export class ManagerLocal extends Manager {
         // Get package information from registry.
         const pkg = this.getPackage(slug);
         if (!pkg)
-            return this.log(`Package ${slug} not found in registry`);
+            throw new Error(`Package ${slug} not found in registry`);
         const versionNum = version || pkg.latestVersion();
         const pkgVersion = pkg?.getVersion(versionNum);
         if (!pkgVersion)
-            return this.log(`Package ${slug} version ${versionNum} not found in registry`);
+            throw new Error(`Package ${slug} version ${versionNum} not found in registry`);
         if (this.isPackageInstalled(slug, versionNum)) {
             this.log(`Package ${slug} version ${versionNum} already installed`);
             pkgVersion.installed = true;
             return pkgVersion;
         }
+        // Check for compatible files before running admin command
+        const excludedFormats = [];
+        const system = getSystem();
+        if (system === SystemType.Linux) {
+            if (!(await commandExists('dpkg')))
+                excludedFormats.push(FileFormat.DebianPackage);
+            if (!(await commandExists('rpm')))
+                excludedFormats.push(FileFormat.RedHatPackage);
+        }
+        const files = packageCompatibleFiles(pkgVersion, [getArchitecture()], [getSystem()], excludedFormats);
+        if (!files.length)
+            throw new Error(`No compatible files found for ${slug}`);
         // Elevate permissions if not running as admin.
         if (!isAdmin() && !isTests()) {
             let command = `--appDir "${this.config.get('appDir')}" --operation "install" --type "${this.type}" --id "${slug}"`;
@@ -191,19 +206,6 @@ export class ManagerLocal extends Manager {
         // Create temporary directory to store downloaded files.
         const dirDownloads = path.join(this.config.get('appDir'), 'downloads', this.type, slug, versionNum);
         dirCreate(dirDownloads);
-        // Not all Linux distributions support all file formats.
-        const excludedFormats = [];
-        const system = getSystem();
-        if (system === SystemType.Linux) {
-            if (!(await commandExists('dpkg')))
-                excludedFormats.push(FileFormat.DebianPackage);
-            if (!(await commandExists('rpm')))
-                excludedFormats.push(FileFormat.RedHatPackage);
-        }
-        // Filter for compatible files and download.
-        const files = packageCompatibleFiles(pkgVersion, [getArchitecture()], [getSystem()], excludedFormats);
-        if (!files.length)
-            return this.log(`Error: No compatible files found for ${slug}`);
         for (const key in files) {
             // Download file to temporary directory if not already downloaded.
             const file = files[key];
@@ -215,9 +217,10 @@ export class ManagerLocal extends Manager {
             // Check file hash matches expected hash.
             const hash = await fileHash(filePath);
             if (hash !== file.sha256)
-                return this.log(`Error: ${filePath} hash mismatch`);
+                throw new Error(`${filePath} hash mismatch`);
             // If installer, run the installer headless (without the user interface).
             if (file.type === FileType.Installer) {
+                // Test time out if installing during tests.
                 if (isTests())
                     fileOpen(filePath);
                 else
@@ -234,9 +237,11 @@ export class ManagerLocal extends Manager {
                 const dirSource = path.join(this.config.get('appDir'), file.type, this.type, slug, versionNum);
                 const dirSub = path.join(slug, versionNum);
                 let formatDir = pluginFormatDir;
-                if (this.type === RegistryType.Presets)
+                if (this.type === RegistryType.Apps)
+                    formatDir = pluginFormatDir;
+                else if (this.type === RegistryType.Presets)
                     formatDir = presetFormatDir;
-                if (this.type === RegistryType.Projects)
+                else if (this.type === RegistryType.Projects)
                     formatDir = projectFormatDir;
                 await archiveExtract(filePath, dirSource);
                 // Move entire directory, maintaining the same folder structure.
@@ -319,41 +324,49 @@ export class ManagerLocal extends Manager {
         // Get package information
         const pkg = this.getPackage(slug);
         if (!pkg) {
-            this.log(`Package ${slug} not found`);
-            return false;
+            throw new Error(`Package ${slug} not found`);
         }
         const versionNum = version || pkg.latestVersion();
         const pkgVersion = pkg.getVersion(versionNum);
         if (!pkgVersion) {
-            this.log(`Package ${slug} version ${versionNum} not found`);
-            return false;
+            throw new Error(`Package ${slug} version ${versionNum} not found`);
         }
         // Check if package is installed
         if (!this.isPackageInstalled(slug, versionNum)) {
-            this.log(`Package ${slug} version ${versionNum} not installed`);
-            return false;
+            throw new Error(`Package ${slug} version ${versionNum} not installed`);
         }
         // Filter compatible files and find one with open field
         const files = packageCompatibleFiles(pkgVersion, [getArchitecture()], [getSystem()], []);
         const openableFile = files.find(file => file.open);
         if (!openableFile) {
-            this.log(`Package ${slug} has no compatible file with open command defined`);
-            return false;
+            throw new Error(`Package ${slug} has no compatible file with open command defined`);
         }
         try {
             const openPath = openableFile.open;
-            const fileExt = path.extname(openableFile.url).slice(1).toLowerCase();
-            const formatDir = pluginFormatDir[fileExt];
+            const fileExt = path.extname(openPath).slice(1).toLowerCase();
+            let formatDir = pluginFormatDir[fileExt] || 'Plugin';
+            if (this.type === RegistryType.Apps)
+                formatDir = pluginFormatDir[fileExt] || 'App';
+            else if (this.type === RegistryType.Presets)
+                formatDir = presetFormatDir[fileExt] || 'Preset';
+            else if (this.type === RegistryType.Projects)
+                formatDir = projectFormatDir[fileExt] || 'Project';
             const packageDir = path.join(this.typeDir, formatDir, slug, versionNum);
-            const fullPath = path.isAbsolute(openPath) ? openPath : path.join(packageDir, openPath);
-            const command = `"${fullPath}" ${options.join(' ')}`;
-            this.log(`Running: ${command}`);
-            if (isTests()) {
-                this.log(`Would run: ${command}`);
+            let fullPath;
+            if (path.isAbsolute(openPath)) {
+                fullPath = openPath;
+            }
+            else if (fileExt === 'app') {
+                // For .app bundles, construct path to executable inside Contents/MacOS/
+                const appName = path.basename(openPath, '.app');
+                fullPath = path.join(packageDir, openPath, 'Contents', 'MacOS', appName);
             }
             else {
-                fileOpen(fullPath);
+                fullPath = path.join(packageDir, openPath);
             }
+            const command = `"${fullPath}" ${options.join(' ')}`;
+            this.log(`Running: ${command}`);
+            fileOpen(fullPath, options);
             return true;
         }
         catch (error) {
@@ -365,13 +378,13 @@ export class ManagerLocal extends Manager {
         // Get package information from registry.
         const pkg = this.getPackage(slug);
         if (!pkg)
-            return this.log(`Package ${slug} not found in registry`);
+            throw new Error(`Package ${slug} not found in registry`);
         const versionNum = version || pkg.latestVersion();
         const pkgVersion = pkg?.getVersion(versionNum);
         if (!pkgVersion)
-            return this.log(`Package ${slug} version ${versionNum} not found in registry`);
+            throw new Error(`Package ${slug} version ${versionNum} not found in registry`);
         if (!this.isPackageInstalled(slug, versionNum))
-            return this.log(`Package ${slug} version ${versionNum} not installed`);
+            throw new Error(`Package ${slug} version ${versionNum} not installed`);
         // Elevate permissions if not running as admin.
         if (!isAdmin() && !isTests()) {
             let command = `--appDir "${this.config.get('appDir')}" --operation "uninstall" --type "${this.type}" --id "${slug}"`;

package/build/helpers/file.d.ts

@@ -33,7 +33,7 @@ export declare function fileHash(filePath: string, algorithm?: string): Promise<
 export declare function fileInstall(filePath: string): Buffer<ArrayBufferLike>;
 export declare function fileMove(filePath: string, newPath: string): void | boolean;
 export declare function filesMove(dirSource: string, dirTarget: string, dirSub: string, formatDir: Record<string, string>): string[];
-export declare function fileOpen(filePath: string): Buffer<ArrayBufferLike>;
+export declare function fileOpen(filePath: string, options?: string[]): import("child_process").ChildProcess | Buffer<ArrayBufferLike>;
 export declare function fileRead(filePath: string): string;
 export declare function fileReadJson(filePath: string): any;
 export declare function fileReadString(filePath: string): string;

package/build/helpers/file.js

@@ -247,8 +247,9 @@ export function fileMove(filePath, newPath) {
     return false;
 }
 export function filesMove(dirSource, dirTarget, dirSub, formatDir) {
-    // Read files from source directory, ignoring Mac Contents files.
-    const files = dirRead(`${dirSource}/**/*.*`);
+    // Read all files from source directory, ignoring Mac Contents files.
+    const allFiles = dirRead(`${dirSource}/**/*`);
+    const files = allFiles.filter(f => !dirIs(f));
     const filesMoved = [];
     // For each file, move to correct folder based on type
     files.forEach((fileSource) => {
@@ -256,24 +257,46 @@ export function filesMove(dirSource, dirTarget, dirSub, formatDir) {
         const fileExtTarget = formatDir[fileExt];
         // If this is not a supported file format, then ignore.
         if (fileExtTarget === undefined)
-            return log(`${fileSource} - ${fileExt} not mapped to a installation folder, skipping.`);
+            return log(`${fileSource} - ${fileExt || 'no extension'} not mapped to a installation folder, skipping.`);
         const fileTarget = path.join(dirTarget, fileExtTarget, dirSub, path.basename(fileSource));
         if (fileExists(fileTarget))
             return log(`${fileSource} - ${fileTarget} already exists, skipping.`);
         dirCreate(path.dirname(fileTarget));
         fileMove(fileSource, fileTarget);
+        // Set executable permissions for executable file types
+        if (fileExt === 'app') {
+            // For .app bundles, find and set permissions on the actual executable
+            const executablePath = path.join(fileTarget, 'Contents', 'MacOS', path.basename(fileTarget, '.app'));
+            if (fileExists(executablePath)) {
+                fileExec(executablePath);
+            }
+        }
+        else if (['elf', 'exe', ''].includes(fileExt)) {
+            fileExec(fileTarget);
+        }
         filesMoved.push(fileTarget);
     });
     return filesMoved;
 }
-export function fileOpen(filePath) {
-    let command = '';
+export function fileOpen(filePath, options = []) {
     if (process.env.CI)
         return Buffer.from('');
+    if (getSystem() === SystemType.Mac) {
+        const isExecutable = !path.extname(filePath);
+        if (isExecutable) {
+            // Use spawn for executables with stdio inherit to show output
+            log('⎋', `spawn "${filePath}" ${options.join(' ')}`);
+            const child = spawn(filePath, options, { stdio: 'inherit' });
+            return child;
+        }
+        else {
+            log('⎋', `open "${filePath}"`);
+            return execSync(`open "${filePath}"`);
+        }
+    }
+    let command = '';
     if (getSystem() === SystemType.Win)
         command = 'start ""';
-    else if (getSystem() === SystemType.Mac)
-        command = 'open';
     else
         command = 'xdg-open';
     log('⎋', `${command} "${filePath}"`);

package/build/types/PluginFormat.d.ts

@@ -19,7 +19,9 @@ export declare enum PluginFormat {
 export type PluginFormatDir = {
     [format in PluginFormat]: string;
 };
-export declare const pluginFormatDir: PluginFormatDir;
+export declare const pluginFormatDir: PluginFormatDir & {
+    '': string;
+};
 export interface PluginFormatOption {
     description: string;
     value: PluginFormat;

package/build/types/PluginFormat.js

@@ -34,6 +34,7 @@ export const pluginFormatDir = {
     [PluginFormat.VSTMac]: 'VST',
     [PluginFormat.VSTWin]: 'VST',
     [PluginFormat.WinStandalone]: 'Exe',
+    '': 'App',
 };
 export const pluginFormats = [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-audio-stack/core",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "Open-source audio plugin management software",
   "type": "module",
   "main": "./build/index.js",