codify-plugin-lib 1.0.182-beta4 → 1.0.182-beta40

package/dist/utils/file-utils.js

@@ -0,0 +1,186 @@
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+import { Utils } from './index.js';
+const SPACE_REGEX = /^\s*$/;
+export class FileUtils {
+    static async downloadFile(url, destination) {
+        console.log(`Downloading file from ${url} to ${destination}`);
+        const { body } = await fetch(url);
+        const dirname = path.dirname(destination);
+        if (!await fs.stat(dirname).then((s) => s.isDirectory()).catch(() => false)) {
+            await fs.mkdir(dirname, { recursive: true });
+        }
+        const ws = fsSync.createWriteStream(destination);
+        // Different type definitions here for readable stream (NodeJS vs DOM). Small hack to fix that
+        await finished(Readable.fromWeb(body).pipe(ws));
+        console.log(`Finished downloading to ${destination}`);
+    }
+    static async addToShellRc(line) {
+        const lineToInsert = addLeadingSpacer(addTrailingSpacer(line));
+        await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert);
+        function addLeadingSpacer(line) {
+            return line.startsWith('\n')
+                ? line
+                : '\n' + line;
+        }
+        function addTrailingSpacer(line) {
+            return line.endsWith('\n')
+                ? line
+                : line + '\n';
+        }
+    }
+    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);
+    }
+    /**
+     * 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) {
+            await fs.appendFile(shellRc, `\nexport PATH=$PATH:${value};`, { encoding: 'utf8' });
+            return;
+        }
+        await fs.appendFile(shellRc, `\nexport PATH=${value}:$PATH;`, { encoding: 'utf8' });
+    }
+    static async removeFromFile(filePath, search) {
+        const contents = await fs.readFile(filePath, 'utf8');
+        const newContents = contents.replaceAll(search, '');
+        await fs.writeFile(filePath, newContents, 'utf8');
+    }
+    static async removeLineFromFile(filePath, search) {
+        const file = await fs.readFile(filePath, 'utf8');
+        const lines = file.split('\n');
+        let searchRegex;
+        let searchString;
+        if (typeof search === 'object') {
+            const startRegex = /^([\t ]*)?/;
+            const endRegex = /([\t ]*)?/;
+            // Augment regex with spaces criteria to make sure this function is not deleting lines that are comments or has other content.
+            searchRegex = search
+                ? new RegExp(startRegex.source + search.source + endRegex.source, search.flags)
+                : search;
+        }
+        if (typeof search === 'string') {
+            searchString = search;
+        }
+        for (let counter = lines.length; counter >= 0; counter--) {
+            if (!lines[counter]) {
+                continue;
+            }
+            if (searchString && lines[counter].includes(searchString)) {
+                lines.splice(counter, 1);
+                continue;
+            }
+            if (searchRegex && lines[counter].search(searchRegex) !== -1) {
+                lines.splice(counter, 1);
+            }
+        }
+        await fs.writeFile(filePath, lines.join('\n'));
+        console.log(`Removed line: ${search} from ${filePath}`);
+    }
+    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;
+    //
+    // newline;
+    static appendToFileWithSpacing(file, textToInsert) {
+        const lines = file.trimEnd().split(/\n/);
+        if (lines.length === 0) {
+            return textToInsert;
+        }
+        const endingNewLines = FileUtils.calculateEndingNewLines(lines);
+        const numNewLines = endingNewLines === -1
+            ? 0
+            : 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) {
+        let counter = 0;
+        while (true) {
+            const line = lines.at(-counter - 1);
+            if (!line) {
+                return -1;
+            }
+            if (!SPACE_REGEX.test(line)) {
+                return counter;
+            }
+            counter++;
+            // Short circuit here because we don't need to check over 2;
+            if (counter > 2) {
+                return counter;
+            }
+        }
+    }
+}

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,11 @@ 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>;
 };

package/dist/utils/index.js

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
+import { getPty, SpawnStatus } from '../pty/index.js';
 export function isDebug() {
     return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
@@ -28,6 +29,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 +132,10 @@ 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);
+    },
 };

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-beta4",
+  "version": "1.0.182-beta40",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -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-beta7",
     "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/src/index.ts

@@ -12,9 +12,10 @@ 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 './utils/functions.js'
 
 export async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);

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',

package/src/plugin/plugin.ts

@@ -22,10 +22,12 @@ import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
 import { getPty } from '../pty/index.js';
 import { SequentialPty } from '../pty/seqeuntial-pty.js';
-import { Resource } from '../resource/resource.js';
 import { ResourceController } from '../resource/resource-controller.js';
+import { listAllResources } from '../utils/load-resources.js';
+import { findNearestPackageJson, readNearestPackageJson } from '../utils/package-json-utils.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
 import { VerbosityLevel } from '../utils/verbosity-level.js';
+import path from 'node:path';
 
 export class Plugin {
   planStorage: Map<string, Plan<any>>;
@@ -33,12 +35,27 @@ export class Plugin {
 
   constructor(
     public name: string,
+    public version: string,
     public resourceControllers: Map<string, ResourceController<ResourceConfig>>
   ) {
     this.planStorage = new Map();
   }
 
-  static create(name: string, resources: Resource<any>[]) {
+  static async create() {
+    const packageJson = readNearestPackageJson();
+    if (!packageJson) {
+      throw new Error('Failed to read nearest package.json');
+    }
+
+    const { name, version } = packageJson;
+
+    const resourceLocations = await listAllResources();
+    const resources = await Promise.all(resourceLocations.map((l) => {
+      return import(l).then((r) => r.default ?? r);
+    }))
+
+    console.log(resources);
+
     const controllers = resources
       .map((resource) => new ResourceController(resource))
 
@@ -46,7 +63,7 @@ export class Plugin {
       controllers.map((r) => [r.typeId, r] as const)
     );
 
-    return new Plugin(name, controllersMap);
+    return new Plugin(name, version, controllersMap);
   }
 
   async initialize(data: InitializeRequestData): Promise<InitializeResponseData> {
@@ -89,7 +106,7 @@ export class Plugin {
 
     const resource = this.resourceControllers.get(data.type)!;
 
-    const schema = resource.settings.schema as JSONSchemaType<any> | undefined;
+    const schema = resource.parsedSettings.schema as JSONSchemaType<any> | undefined;
     const requiredPropertyNames = (
       resource.settings.importAndDestroy?.requiredParameters
       ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)

package/src/pty/background-pty.ts

@@ -20,8 +20,10 @@ EventEmitter.defaultMaxListeners = 1000;
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export class BackgroundPty implements IPty {
+  private historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
   private basePty = pty.spawn(this.getDefaultShell(), ['-i'], {
-    env: process.env, name: nanoid(6),
+    env: { ...process.env, ...this.historyIgnore },
+    name: nanoid(6),
     handleFlowControl: true
   });
 
@@ -31,17 +33,19 @@ export class BackgroundPty implements IPty {
     this.initialize();
   }
 
-  async spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult> {
+  async spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult> {
     const spawnResult = await this.spawnSafe(cmd, options);
 
     if (spawnResult.status !== 'success') {
-      throw new SpawnError(cmd, spawnResult.exitCode, spawnResult.data);
+      throw new SpawnError(Array.isArray(cmd) ? cmd.join(' ') : cmd, spawnResult.exitCode, spawnResult.data);
     }
 
     return spawnResult;
   }
 
-  async spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult> {
+  async spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult> {
+    cmd = Array.isArray(cmd) ? cmd.join('\\\n') : cmd;
+
     // cid is command id
     const cid = nanoid(10);
     debugLog(cid);
@@ -102,7 +106,7 @@ export class BackgroundPty implements IPty {
           }
         });
 
-        console.log(`Running command ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`)
+        console.log(`Running command: ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`)
         this.basePty.write(`${command}\r`);
 
       }));
@@ -128,19 +132,6 @@ export class BackgroundPty implements IPty {
       let outputBuffer = '';
 
       return new Promise(resolve => {
-        // zsh-specific commands
-        switch (Utils.getShell()) {
-          case Shell.ZSH: {
-            this.basePty.write('setopt HIST_NO_STORE;\n');
-            break;
-          }
-
-          default: {
-            this.basePty.write('export HISTIGNORE=\'history*\';\n');
-            break;
-          }
-        }
-
         this.basePty.write(' unset PS1;\n');
         this.basePty.write(' unset PS0;\n')
         this.basePty.write(' echo setup complete\\"\n')

package/src/pty/index.ts

@@ -28,8 +28,10 @@ export enum SpawnStatus {
  */
 export interface SpawnOptions {
   cwd?: string;
-  env?: Record<string, unknown>,
-  interactive?: boolean,
+  env?: Record<string, unknown>;
+  interactive?: boolean;
+  requiresRoot?: boolean;
+  stdin?: boolean;
 }
 
 export class SpawnError extends Error {
@@ -48,9 +50,9 @@ export class SpawnError extends Error {
 }
 
 export interface IPty {
-  spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>
+  spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>
 
-  spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>
+  spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>
 
   kill(): Promise<{ exitCode: number, signal?: number | undefined }>
 }