codify-plugin-lib 1.0.182-beta6 → 1.0.182-beta60

package/dist/test.js

@@ -0,0 +1,5 @@
+import { SequentialPty } from './pty/seqeuntial-pty.js';
+import { VerbosityLevel } from './utils/verbosity-level.js';
+VerbosityLevel.set(1);
+const $ = new SequentialPty();
+await $.spawn('sudo ls', { interactive: true });

package/dist/utils/file-utils.d.ts

@@ -1,16 +1,23 @@
 export declare class FileUtils {
     static downloadFile(url: string, destination: string): Promise<void>;
-    static addToStartupFile(line: string): Promise<void>;
-    static addAllToStartupFile(lines: string[]): Promise<void>;
-    static addPathToPrimaryShellRc(value: string, prepend: boolean): Promise<void>;
+    static addToShellRc(line: string): Promise<void>;
+    static addAllToShellRc(lines: string[]): Promise<void>;
+    /**
+     * This method adds a directory path to the shell rc file if it doesn't already exist.
+     *
+     * @param value - The directory path to add.
+     * @param prepend - Whether to prepend the path to the existing PATH variable.
+     */
+    static addPathToShellRc(value: string, prepend: boolean): Promise<void>;
+    static removeFromFile(filePath: string, search: string): Promise<void>;
+    static removeLineFromFile(filePath: string, search: RegExp | string): Promise<void>;
+    static removeLineFromShellRc(search: RegExp | string): Promise<void>;
+    static removeAllLinesFromShellRc(searches: Array<RegExp | string>): Promise<void>;
+    static appendToFileWithSpacing(file: string, textToInsert: string): string;
     static dirExists(path: string): Promise<boolean>;
     static fileExists(path: string): Promise<boolean>;
     static exists(path: string): Promise<boolean>;
     static checkDirExistsOrThrowIfFile(path: string): Promise<boolean>;
     static createDirIfNotExists(path: string): Promise<void>;
-    static removeFromFile(filePath: string, search: string): Promise<void>;
-    static removeLineFromFile(filePath: string, search: RegExp | string): Promise<void>;
-    static removeLineFromPrimaryShellRc(search: RegExp | string): Promise<void>;
-    static appendToFileWithSpacing(file: string, textToInsert: string): string;
     private static calculateEndingNewLines;
 }

package/dist/utils/file-utils.js

@@ -18,7 +18,7 @@ export class FileUtils {
         await finished(Readable.fromWeb(body).pipe(ws));
         console.log(`Finished downloading to ${destination}`);
     }
-    static async addToStartupFile(line) {
+    static async addToShellRc(line) {
         const lineToInsert = addLeadingSpacer(addTrailingSpacer(line));
         await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert);
         function addLeadingSpacer(line) {
@@ -32,14 +32,23 @@ export class FileUtils {
                 : line + '\n';
         }
     }
-    static async addAllToStartupFile(lines) {
+    static async addAllToShellRc(lines) {
         const formattedLines = '\n' + lines.join('\n') + '\n';
         const shellRc = Utils.getPrimaryShellRc();
         console.log(`Adding to ${path.basename(shellRc)}:
 ${lines.join('\n')}`);
         await fs.appendFile(shellRc, formattedLines);
     }
-    static async addPathToPrimaryShellRc(value, prepend) {
+    /**
+     * This method adds a directory path to the shell rc file if it doesn't already exist.
+     *
+     * @param value - The directory path to add.
+     * @param prepend - Whether to prepend the path to the existing PATH variable.
+     */
+    static async addPathToShellRc(value, prepend) {
+        if (await Utils.isDirectoryOnPath(value)) {
+            return;
+        }
         const shellRc = Utils.getPrimaryShellRc();
         console.log(`Saving path: ${value} to ${shellRc}`);
         if (prepend) {
@@ -48,53 +57,6 @@ ${lines.join('\n')}`);
         }
         await fs.appendFile(shellRc, `\nexport PATH=${value}:$PATH;`, { encoding: 'utf8' });
     }
-    static async dirExists(path) {
-        let stat;
-        try {
-            stat = await fs.stat(path);
-            return stat.isDirectory();
-        }
-        catch {
-            return false;
-        }
-    }
-    static async fileExists(path) {
-        let stat;
-        try {
-            stat = await fs.stat(path);
-            return stat.isFile();
-        }
-        catch {
-            return false;
-        }
-    }
-    static async exists(path) {
-        try {
-            await fs.stat(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    static async checkDirExistsOrThrowIfFile(path) {
-        let stat;
-        try {
-            stat = await fs.stat(path);
-        }
-        catch {
-            return false;
-        }
-        if (stat.isDirectory()) {
-            return true;
-        }
-        throw new Error(`Directory ${path} already exists and is a file`);
-    }
-    static async createDirIfNotExists(path) {
-        if (!fsSync.existsSync(path)) {
-            await fs.mkdir(path, { recursive: true });
-        }
-    }
     static async removeFromFile(filePath, search) {
         const contents = await fs.readFile(filePath, 'utf8');
         const newContents = contents.replaceAll(search, '');
@@ -131,9 +93,14 @@ ${lines.join('\n')}`);
         await fs.writeFile(filePath, lines.join('\n'));
         console.log(`Removed line: ${search} from ${filePath}`);
     }
-    static async removeLineFromPrimaryShellRc(search) {
+    static async removeLineFromShellRc(search) {
         return FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
     }
+    static async removeAllLinesFromShellRc(searches) {
+        for (const search of searches) {
+            await FileUtils.removeLineFromFile(Utils.getPrimaryShellRc(), search);
+        }
+    }
     // Append the string to the end of a file ensuring at least 1 lines of space between.
     // Ex result:
     // something something;
@@ -150,6 +117,53 @@ ${lines.join('\n')}`);
             : Math.max(0, 2 - endingNewLines);
         return lines.join('\n') + '\n'.repeat(numNewLines) + textToInsert;
     }
+    static async dirExists(path) {
+        let stat;
+        try {
+            stat = await fs.stat(path);
+            return stat.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    static async fileExists(path) {
+        let stat;
+        try {
+            stat = await fs.stat(path);
+            return stat.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    static async exists(path) {
+        try {
+            await fs.stat(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async checkDirExistsOrThrowIfFile(path) {
+        let stat;
+        try {
+            stat = await fs.stat(path);
+        }
+        catch {
+            return false;
+        }
+        if (stat.isDirectory()) {
+            return true;
+        }
+        throw new Error(`Directory ${path} already exists and is a file`);
+    }
+    static async createDirIfNotExists(path) {
+        if (!fsSync.existsSync(path)) {
+            await fs.mkdir(path, { recursive: true });
+        }
+    }
     // This is overly complicated but it can be used to insert into any
     // position in the future
     static calculateEndingNewLines(lines) {

package/dist/utils/functions.js

@@ -5,9 +5,10 @@ export function splitUserConfig(config) {
         type: config.type,
         ...(config.name ? { name: config.name } : {}),
         ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
+        ...(config.os ? { os: config.os } : {}),
     };
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { type, name, dependsOn, ...parameters } = config;
+    const { type, name, dependsOn, os, ...parameters } = config;
     return {
         parameters: parameters,
         coreParameters,
@@ -24,7 +25,6 @@ export function tildify(pathWithTilde) {
     return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
 }
 export function resolvePathWithVariables(pathWithVariables) {
-    // @ts-expect-error Ignore this for now
     return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b]);
 }
 export function addVariablesToPath(pathWithoutVariables) {

package/dist/utils/index.d.ts

@@ -20,7 +20,19 @@ export declare const Utils: {
     };
     isMacOS(): boolean;
     isLinux(): boolean;
+    isArmArch(): Promise<boolean>;
+    isHomebrewInstalled(): Promise<boolean>;
+    isRosetta2Installed(): Promise<boolean>;
     getShell(): Shell | undefined;
     getPrimaryShellRc(): string;
     getShellRcFiles(): string[];
+    isDirectoryOnPath(directory: string): Promise<boolean>;
+    assertBrewInstalled(): Promise<void>;
+    /**
+     * Installs a package via the system package manager. This will use Homebrew on macOS and apt on Ubuntu/Debian or dnf on Fedora.
+     * @param packageName
+     */
+    installViaPkgMgr(packageName: string): Promise<boolean>;
+    uninstallViaPkgMgr(packageName: string): Promise<boolean>;
+    linuxDistro(): Promise<"arch" | "centos" | "debian" | "fedora" | "rhel" | "ubuntu" | undefined>;
 };

package/dist/utils/index.js

@@ -1,5 +1,7 @@
+import * as fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { SpawnStatus, getPty } from '../pty/index.js';
 export function isDebug() {
     return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
@@ -28,6 +30,29 @@ export const Utils = {
     isLinux() {
         return os.platform() === 'linux';
     },
+    async isArmArch() {
+        const $ = getPty();
+        if (!Utils.isMacOS()) {
+            // On Linux, check uname -m
+            const query = await $.spawn('uname -m');
+            return query.data.trim() === 'aarch64' || query.data.trim() === 'arm64';
+        }
+        const query = await $.spawn('sysctl -n machdep.cpu.brand_string');
+        return /M(\d)/.test(query.data);
+    },
+    async isHomebrewInstalled() {
+        const $ = getPty();
+        const query = await $.spawnSafe('which brew', { interactive: true });
+        return query.status === SpawnStatus.SUCCESS;
+    },
+    async isRosetta2Installed() {
+        if (!Utils.isMacOS()) {
+            return false;
+        }
+        const $ = getPty();
+        const query = await $.spawnSafe('arch -x86_64 /usr/bin/true 2> /dev/null', { interactive: true });
+        return query.status === SpawnStatus.SUCCESS;
+    },
     getShell() {
         const shell = process.env.SHELL || '';
         if (shell.endsWith('bash')) {
@@ -108,4 +133,90 @@ export const Utils = {
             path.join(homeDir, '.profile'),
         ];
     },
+    async isDirectoryOnPath(directory) {
+        const $ = getPty();
+        const { data: pathQuery } = await $.spawn('echo $PATH', { interactive: true });
+        const lines = pathQuery.split(':');
+        return lines.includes(directory);
+    },
+    async assertBrewInstalled() {
+        const $ = getPty();
+        const brewCheck = await $.spawnSafe('which brew', { interactive: true });
+        if (brewCheck.status === SpawnStatus.ERROR) {
+            throw new Error(`Homebrew is not installed. Cannot install git-lfs without Homebrew installed.
+
+Brew can be installed using Codify:
+{
+  "type": "homebrew",
+}`);
+        }
+    },
+    /**
+     * Installs a package via the system package manager. This will use Homebrew on macOS and apt on Ubuntu/Debian or dnf on Fedora.
+     * @param packageName
+     */
+    async installViaPkgMgr(packageName) {
+        const $ = getPty();
+        if (Utils.isMacOS()) {
+            await this.assertBrewInstalled();
+            const { status } = await $.spawnSafe(`brew install ${packageName}`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1 } });
+            return status === SpawnStatus.SUCCESS;
+        }
+        if (Utils.isLinux()) {
+            const isAptInstalled = await $.spawnSafe('which apt');
+            if (isAptInstalled.status === SpawnStatus.SUCCESS) {
+                const { status } = await $.spawnSafe(`apt install ${packageName}`, { interactive: true, requiresRoot: true, env: { DEBIAN_FRONTEND: 'noninteractive' } });
+                return status === SpawnStatus.SUCCESS;
+            }
+            const isDnfInstalled = await $.spawnSafe('which dnf');
+            if (isDnfInstalled.status === SpawnStatus.SUCCESS) {
+                const { status } = await $.spawnSafe(`dnf install ${packageName} -y`, { interactive: true, requiresRoot: true });
+                return status === SpawnStatus.SUCCESS;
+            }
+            const isYumInstalled = await $.spawnSafe('which yum');
+            if (isYumInstalled.status === SpawnStatus.SUCCESS) {
+                const { status } = await $.spawnSafe(`yum install ${packageName} -y`, { interactive: true, requiresRoot: true });
+                return status === SpawnStatus.SUCCESS;
+            }
+            return false;
+        }
+        return false;
+    },
+    async uninstallViaPkgMgr(packageName) {
+        const $ = getPty();
+        if (Utils.isMacOS()) {
+            await this.assertBrewInstalled();
+            const { status } = await $.spawnSafe(`brew uninstall --zap ${packageName}`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1 } });
+            return status === SpawnStatus.SUCCESS;
+        }
+        if (Utils.isLinux()) {
+            const isAptInstalled = await $.spawnSafe('which apt');
+            if (isAptInstalled.status === SpawnStatus.SUCCESS) {
+                const { status } = await $.spawnSafe(`apt remove --purge ${packageName}`, { interactive: true, requiresRoot: true, env: { DEBIAN_FRONTEND: 'noninteractive' } });
+                return status === SpawnStatus.SUCCESS;
+            }
+            const isDnfInstalled = await $.spawnSafe('which dnf');
+            if (isDnfInstalled.status === SpawnStatus.SUCCESS) {
+                const { status } = await $.spawnSafe(`dnf autoremove ${packageName} -y`, { interactive: true, requiresRoot: true });
+                return status === SpawnStatus.SUCCESS;
+            }
+            const isYumInstalled = await $.spawnSafe('which yum');
+            if (isYumInstalled.status === SpawnStatus.SUCCESS) {
+                const { status } = await $.spawnSafe(`yum autoremove ${packageName} -y`, { interactive: true, requiresRoot: true });
+                return status === SpawnStatus.SUCCESS;
+            }
+            return false;
+        }
+        return false;
+    },
+    async linuxDistro() {
+        const osRelease = await fs.readFile('/etc/os-release', 'utf8');
+        const lines = osRelease.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('ID=')) {
+                return line.slice(3).trim();
+            }
+        }
+        return undefined;
+    }
 };

package/dist/utils/load-resources.d.ts

@@ -0,0 +1 @@
+export declare const listAllResources: (root?: string) => Promise<string[]>;

package/dist/utils/load-resources.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as url from 'node:url';
+export const listAllResources = async (root = path.join(path.dirname(url.fileURLToPath(import.meta.url)), '..', '..', '..', '..')) => {
+    console.log('Dirname', root);
+    const resourcesPath = path.join(root, 'src', 'resources');
+    const resourceDir = await fs.readdir(resourcesPath);
+    const dedupSet = new Set();
+    const result = new Set();
+    for (const folder of resourceDir) {
+        if (await fs.stat(path.join(resourcesPath, folder)).then(s => s.isDirectory()).catch(() => false)) {
+            for (const folderContents of await fs.readdir(path.join(resourcesPath, folder))) {
+                const isDirectory = await fs.stat(path.join(resourcesPath, folder, folderContents)).then(s => s.isDirectory());
+                // console.log(folderContents, isDirectory);
+                if (isDirectory) {
+                    for (const innerContents of await fs.readdir(path.join(resourcesPath, folder, folderContents))) {
+                        if (!dedupSet.has(path.join(resourcesPath, folder, folderContents))) {
+                            dedupSet.add(path.join(resourcesPath, folder, folderContents));
+                            addResourceFromDir(path.join(resourcesPath, folder, folderContents), result);
+                        }
+                    }
+                }
+                else {
+                    if (!dedupSet.has(path.join(resourcesPath, folder))) {
+                        dedupSet.add(path.join(resourcesPath, folder));
+                        addResourceFromDir(path.join(resourcesPath, folder), result);
+                    }
+                }
+            }
+        }
+        else {
+            throw new Error('Only directories are allowed in resources folder');
+        }
+    }
+    return [...result];
+};
+function addResourceFromDir(dir, result) {
+    try {
+        const resourceFile = path.resolve(path.join(dir, 'resource.ts'));
+        if (!(fs.stat(resourceFile).then((s) => s.isFile())).catch(() => false)) {
+            return;
+        }
+        result.add(resourceFile);
+    }
+    catch { }
+}

package/dist/utils/package-json-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Find the nearest package.json starting from a directory and walking upward.
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Absolute path to package.json or null if not found
+ */
+export declare function findNearestPackageJson(startDir?: string): string | null;
+/**
+ * Read and parse the nearest package.json
+ * @param {string} startDir
+ * @returns {object|null}
+ */
+export declare function readNearestPackageJson(startDir?: string): any;

package/dist/utils/package-json-utils.js

@@ -0,0 +1,34 @@
+import * as fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Find the nearest package.json starting from a directory and walking upward.
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Absolute path to package.json or null if not found
+ */
+export function findNearestPackageJson(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const pkgPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            return pkgPath;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            // Reached filesystem root
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+/**
+ * Read and parse the nearest package.json
+ * @param {string} startDir
+ * @returns {object|null}
+ */
+export function readNearestPackageJson(startDir = process.cwd()) {
+    const pkgPath = findNearestPackageJson(startDir);
+    if (!pkgPath)
+        return null;
+    const contents = fs.readFileSync(pkgPath, 'utf8');
+    return JSON.parse(contents);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta6",
+  "version": "1.0.182-beta60",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -11,7 +11,7 @@
     "prepublishOnly": "tsc"
   },
   "bin": {
-    "codify-deploy": "./dist/bin/deploy-plugin.js"
+    "codify-build": "./bin/build.js"
   },
   "keywords": [],
   "author": "",
@@ -22,11 +22,12 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "clean-deep": "^3.4.0",
-    "codify-schemas": "1.0.86",
+    "codify-schemas": "1.0.86-beta10",
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "zod": "4.1.13"
   },
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.2",

package/rollup.config.js

@@ -0,0 +1,24 @@
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'src/index.ts',
+  output: {
+    dir: 'dist',
+    format: 'cjs',
+    inlineDynamicImports: true,
+  },
+  external: ['@homebridge/node-pty-prebuilt-multiarch'],
+  plugins: [
+    json(),
+    nodeResolve({ exportConditions: ['node'] }),
+    typescript({
+      exclude: ['**/*.test.ts', '**/*.d.ts', 'test']
+    }),
+    commonjs(),
+    terser()
+  ]
+}

package/src/index.ts

@@ -7,14 +7,18 @@ export * from './plan/change-set.js'
 export * from './plan/plan.js'
 export * from './plan/plan-types.js'
 export * from './plugin/plugin.js'
+export * from './pty/background-pty.js';
 export * from './pty/index.js'
+export * from './pty/seqeuntial-pty.js';
 export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js'
 export * from './resource/resource-settings.js'
 export * from './stateful-parameter/stateful-parameter.js'
+export * from './utils/file-utils.js'
 export * from './utils/functions.js'
 export * from './utils/index.js'
 export * from './utils/verbosity-level.js'
+export * from 'zod/v4';
 
 export async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);

package/src/messages/handlers.test.ts

@@ -235,6 +235,29 @@ describe('Message handler tests', () => {
     process.send = undefined;
   })
 
+  it('handles changing the verbosity level', async () => {
+    const resource = new TestResource()
+    const plugin = testPlugin(resource);
+    const handler = new MessageHandler(plugin);
+
+    process.send = (message) => {
+      expect(message).toMatchObject({
+        cmd: 'setVerbosityLevel_Response',
+        status: MessageStatus.SUCCESS,
+      })
+      return true;
+    }
+
+    expect(async () => await handler.onMessage({
+      cmd: 'setVerbosityLevel',
+      data: {
+        verbosityLevel: 2,
+      }
+    })).rejects.to.not.throw;
+
+    process.send = undefined;
+  })
+
   it('Supports ipc message v2 (success)', async () => {
     const resource = new TestResource()
     const plugin = testPlugin(resource);

package/src/messages/handlers.ts

@@ -2,7 +2,7 @@ import { Ajv, SchemaObject, ValidateFunction } from 'ajv';
 import addFormats from 'ajv-formats';
 import {
   ApplyRequestDataSchema,
-  ApplyResponseDataSchema,
+  EmptyResponseDataSchema,
   GetResourceInfoRequestDataSchema,
   GetResourceInfoResponseDataSchema,
   ImportRequestDataSchema,
@@ -19,6 +19,7 @@ import {
   PlanRequestDataSchema,
   PlanResponseDataSchema,
   ResourceSchema,
+  SetVerbosityRequestDataSchema,
   ValidateRequestDataSchema,
   ValidateResponseDataSchema
 } from 'codify-schemas';
@@ -42,6 +43,14 @@ const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) =
     requestValidator: GetResourceInfoRequestDataSchema,
     responseValidator: GetResourceInfoResponseDataSchema
   },
+  'setVerbosityLevel': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.setVerbosityLevel(data)
+      return null;
+    },
+    requestValidator: SetVerbosityRequestDataSchema,
+    responseValidator: EmptyResponseDataSchema,
+  },
   'match': {
     handler: async (plugin: Plugin, data: any) => plugin.match(data),
     requestValidator: MatchRequestDataSchema,
@@ -63,7 +72,7 @@ const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) =
       return null;
     },
     requestValidator: ApplyRequestDataSchema,
-    responseValidator: ApplyResponseDataSchema
+    responseValidator: EmptyResponseDataSchema
   },
 }
 

package/src/plugin/plugin.test.ts

@@ -7,6 +7,7 @@ import { spy } from 'sinon';
 import { ResourceSettings } from '../resource/resource-settings.js';
 import { TestConfig, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { getPty } from '../pty/index.js';
+import { z } from 'zod';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -170,6 +171,36 @@ describe('Plugin tests', () => {
     })
   })
 
+  it('Can get resource info (zod schema)', async () => {
+    const schema = z
+      .object({
+        plugins: z
+          .array(z.string())
+          .describe(
+            'Asdf plugins to install. See: https://github.com/asdf-community for a full list'
+          )
+      })
+      .strict()
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'typeId',
+          operatingSystems: [OS.Darwin],
+          schema,
+        }
+      }
+    }
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const resourceInfo = await testPlugin.getResourceInfo({ type: 'typeId' })
+    expect(resourceInfo.import).toMatchObject({
+      requiredParameters: [
+        'plugins'
+      ]
+    })
+  })
+
   it('Get resource info to default import to the one specified in the resource settings', async () => {
     const schema = {
       '$schema': 'http://json-schema.org/draft-07/schema',