@codifycli/plugin-core 1.2.2 → 1.2.3-beta.1

package/dist/utils/spawn-2.js

@@ -0,0 +1,7 @@
+import { $ } from 'zx';
+export class ShellContext {
+    zx = $({ shell: true });
+    static create() {
+        return new ShellContext();
+    }
+}

package/dist/utils/spawn.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+import { SpawnOptions } from 'node:child_process';
+export declare enum SpawnStatus {
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface SpawnResult {
+    status: SpawnStatus;
+    data: string;
+}
+type CodifySpawnOptions = {
+    cwd?: string;
+    throws?: boolean;
+    requiresRoot?: boolean;
+} & Omit<SpawnOptions, 'detached' | 'shell' | 'stdio'>;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export declare function $(cmd: string, opts?: CodifySpawnOptions): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/spawn.js

@@ -0,0 +1,124 @@
+import { Ajv } from 'ajv';
+import { MessageCmd, SudoRequestResponseDataSchema } from 'codify-schemas';
+import { spawn } from 'node:child_process';
+import { SudoError } from '../errors.js';
+const ajv = new Ajv({
+    strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(SudoRequestResponseDataSchema);
+export var SpawnStatus;
+(function (SpawnStatus) {
+    SpawnStatus["SUCCESS"] = "success";
+    SpawnStatus["ERROR"] = "error";
+})(SpawnStatus || (SpawnStatus = {}));
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export async function $(cmd, opts) {
+    const throws = opts?.throws ?? true;
+    console.log(`Running command: ${cmd}`);
+    try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
+        let result;
+        if (!opts?.requiresRoot) {
+            result = await internalSpawn(cmd, opts ?? {});
+        }
+        else {
+            result = await externalSpawnWithSudo(cmd, opts);
+        }
+        if (result.status !== SpawnStatus.SUCCESS) {
+            throw new Error(result.data);
+        }
+        return result;
+    }
+    catch (error) {
+        if (isDebug()) {
+            console.error(`CodifySpawn error for command ${cmd}`, error);
+        }
+        if (error.message?.startsWith('sudo:')) {
+            throw new SudoError(cmd);
+        }
+        if (throws) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            return {
+                status: SpawnStatus.ERROR,
+                data: error.message,
+            };
+        }
+        return {
+            status: SpawnStatus.ERROR,
+            data: error + '',
+        };
+    }
+}
+async function internalSpawn(cmd, opts) {
+    return new Promise((resolve, reject) => {
+        const output = [];
+        // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+        // Ignore all stdin
+        const _process = spawn(`source ~/.zshrc; ${cmd}`, [], {
+            ...opts,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: 'zsh',
+        });
+        const { stdout, stderr, stdin } = _process;
+        stdout.setEncoding('utf8');
+        stderr.setEncoding('utf8');
+        stdout.on('data', (data) => {
+            output.push(data.toString());
+        });
+        stderr.on('data', (data) => {
+            output.push(data.toString());
+        });
+        _process.on('error', (data) => {
+        });
+        // please node that this is not a full replacement for 'inherit'
+        // the child process can and will detect if stdout is a pty and change output based on it
+        // the terminal context is lost & ansi information (coloring) etc will be lost
+        if (stdout && stderr) {
+            stdout.pipe(process.stdout);
+            stderr.pipe(process.stderr);
+        }
+        _process.on('close', (code) => {
+            resolve({
+                status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                data: output.join('\n'),
+            });
+        });
+    });
+}
+async function externalSpawnWithSudo(cmd, opts) {
+    return await new Promise((resolve) => {
+        const listener = (data) => {
+            if (data.cmd === MessageCmd.SUDO_REQUEST + '_Response') {
+                process.removeListener('message', listener);
+                if (!validateSudoRequestResponse(data.data)) {
+                    throw new Error(`Invalid response for sudo request: ${JSON.stringify(validateSudoRequestResponse.errors, null, 2)}`);
+                }
+                resolve(data.data);
+            }
+        };
+        process.on('message', listener);
+        process.send({
+            cmd: MessageCmd.SUDO_REQUEST,
+            data: {
+                command: cmd,
+                options: opts ?? {},
+            }
+        });
+    });
+}
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,18 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+export declare const VerbosityLevel: {
+    level: number;
+    get(): number;
+    set(level: number): void;
+};
+export declare function isDebug(): boolean;
+export declare function splitUserConfig<T extends StringIndexedObject>(config: ResourceConfig & T): {
+    parameters: T;
+    coreParameters: ResourceConfig;
+};
+export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
+export declare function untildify(pathWithTilde: string): string;
+export declare function tildify(pathWithTilde: string): string;
+export declare function resolvePathWithVariables(pathWithVariables: string): string;
+export declare function addVariablesToPath(pathWithoutVariables: string): string;
+export declare function unhome(pathWithHome: string): string;
+export declare function areArraysEqual(isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined, desired: unknown, current: unknown): boolean;

package/dist/utils/utils.js

@@ -0,0 +1,86 @@
+import os from 'node:os';
+import path from 'node:path';
+export const VerbosityLevel = new class {
+    level = 0;
+    get() {
+        return this.level;
+    }
+    set(level) {
+        this.level = level;
+    }
+};
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
+export function splitUserConfig(config) {
+    const coreParameters = {
+        type: config.type,
+        ...(config.name ? { name: config.name } : {}),
+        ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { type, name, dependsOn, ...parameters } = config;
+    return {
+        parameters: parameters,
+        coreParameters,
+    };
+}
+export function setsEqual(set1, set2) {
+    return set1.size === set2.size && [...set1].every((v) => set2.has(v));
+}
+const homeDirectory = os.homedir();
+export function untildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+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) {
+    let result = pathWithoutVariables;
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value || !path.isAbsolute(value) || value === '/' || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
+            continue;
+        }
+        result = result.replaceAll(value, `$${key}`);
+    }
+    return result;
+}
+export function unhome(pathWithHome) {
+    return pathWithHome.includes('$HOME') ? pathWithHome.replaceAll('$HOME', os.homedir()) : pathWithHome;
+}
+export function areArraysEqual(isElementEqual, desired, current) {
+    if (!desired || !current) {
+        return false;
+    }
+    if (!Array.isArray(desired) || !Array.isArray(current)) {
+        throw new Error(`A non-array value:
+          
+Desired: ${JSON.stringify(desired, null, 2)}
+
+Current: ${JSON.stringify(desired, null, 2)}
+
+Was provided even though type array was specified.
+`);
+    }
+    if (desired.length !== current.length) {
+        return false;
+    }
+    const desiredCopy = [...desired];
+    const currentCopy = [...current];
+    // Algorithm for to check equality between two un-ordered; un-hashable arrays using
+    // an isElementEqual method. Time: O(n^2)
+    for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+        const idx = currentCopy.findIndex((e2) => (isElementEqual
+            ?? ((a, b) => a === b))(desiredCopy[counter], e2));
+        if (idx === -1) {
+            return false;
+        }
+        desiredCopy.splice(counter, 1);
+        currentCopy.splice(idx, 1);
+    }
+    return currentCopy.length === 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codifycli/plugin-core",
-  "version": "1.2.2",
+  "version": "1.2.3-beta.1",
   "description": "TypeScript library for building Codify plugins to manage system resources (applications, CLI tools, settings) through infrastructure-as-code",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/messages/sender.ts

@@ -27,18 +27,17 @@ class CodifyCliSenderImpl {
     })
   }
 
-  sendApplyNote(message: string, resourceType?: string): void {
+  async sendApplyNote(message: string, resourceType?: string): Promise<void> {
     if (!process.send || !process.connected) {
       return;
     }
 
-    process.send(<IpcMessageV2>{
+    await this.sendAndWaitForResponse(<IpcMessageV2>{
       cmd: MessageCmd.APPLY_NOTE_REQUEST,
       data: <ApplyNoteRequestData>{
         message,
         ...(resourceType && { resourceType }),
-      },
-      requestId: nanoid(8),
+      }
     });
   }
 

package/src/plan/change-set.test.ts

@@ -304,33 +304,6 @@ describe('Change set tests', () => {
     expect(cs.operation).to.eq(ResourceOperation.DESTROY);
   })
 
-  it('treats empty objects {} as no-op', () => {
-    const desired = {
-      keyboard: {},
-      dock: {},
-    }
-
-    const current = {
-      keyboard: {},
-      dock: {},
-    }
-
-    const cs = ChangeSet.calculateModification(desired, current);
-    expect(cs.parameterChanges.length).to.eq(0);
-    expect(cs.operation).to.eq(ResourceOperation.NOOP);
-  })
-
-  it('treats empty object {} as absent when current has no value', () => {
-    const desired = {
-      keyboard: {},
-      dock: {},
-    }
-
-    const cs = ChangeSet.calculateModification(desired, {});
-    expect(cs.parameterChanges.length).to.eq(0);
-    expect(cs.operation).to.eq(ResourceOperation.NOOP);
-  })
-
   it('correctly determines array equality 5', () => {
     const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];

package/src/plan/change-set.ts

@@ -154,13 +154,13 @@ export class ChangeSet<T extends StringIndexedObject> {
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
-    // Filter out null, undefined, [], and {} — all treated as "no value"
+    // Filter out null and undefined values or else the diff below will not work
     const desired = Object.fromEntries(
-      Object.entries(desiredParameters).filter(([, v]) => !ChangeSet.isAbsent(v))
+      Object.entries(desiredParameters).filter(([, v]) => v !== null && v !== undefined)
     ) as Partial<T>
 
     const current = Object.fromEntries(
-      Object.entries(currentParameters).filter(([, v]) => !ChangeSet.isAbsent(v))
+      Object.entries(currentParameters).filter(([, v]) => v !== null && v !== undefined)
     ) as Partial<T>
 
     for (const k of new Set([...Object.keys(current), ...Object.keys(desired)])) {
@@ -227,13 +227,6 @@ export class ChangeSet<T extends StringIndexedObject> {
     return orderOfOperations[Math.max(indexPrev, indexNext)];
   }
 
-  private static isAbsent(v: unknown): boolean {
-    if (v === null || v === undefined) return true;
-    if (Array.isArray(v)) return v.length === 0;
-    if (typeof v === 'object') return Object.keys(v as object).length === 0;
-    return false;
-  }
-
   private static isSame(
     desired: unknown,
     current: unknown,

package/src/pty/background-pty.ts

@@ -135,6 +135,7 @@ export class BackgroundPty implements IPty {
       return new Promise(resolve => {
         this.basePty.write(' unset PS1;\n');
         this.basePty.write(' unset PS0;\n')
+        this.basePty.write(' unsetopt CORRECT CORRECT_ALL 2>/dev/null; true;\n')
         this.basePty.write(' echo setup complete\\"\n')
 
         const listener = this.basePty.onData((data: string) => {

package/src/pty/seqeuntial-pty.ts

@@ -88,7 +88,9 @@ export class SequentialPty implements IPty {
       const initialCols = options?.disableWrapping ? 10_000 : process.stdout.columns ?? 80
       const initialRows = process.stdout.rows ?? 24;
 
-      const args = options?.interactive ? ['-i', '-c', cmd] : ['-c', cmd]
+      const disableAutocorrect = Utils.getShell() === Shell.ZSH ? 'unsetopt CORRECT CORRECT_ALL 2>/dev/null; ' : '';
+      const wrappedCmd = `${disableAutocorrect}${cmd}`;
+      const args = options?.interactive ? ['-i', '-c', wrappedCmd] : ['-c', wrappedCmd]
 
       // Run the command in a pty for interactivity
       const mPty = pty.spawn(this.getDefaultShell(), args, {

package/src/utils/file-utils.ts

@@ -35,7 +35,7 @@ export class FileUtils {
     );
 
     await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert)
-    CodifyCliSender.sendApplyNote(ApplyNotes.sourceShellRc());
+    await CodifyCliSender.sendApplyNote(ApplyNotes.sourceShellRc());
 
     function addLeadingSpacer(line: string): string {
       return line.startsWith('\n')
@@ -60,7 +60,7 @@ export class FileUtils {
 ${lines.join('\n')}`)
 
     await fs.appendFile(shellRc, formattedLines)
-    CodifyCliSender.sendApplyNote(ApplyNotes.sourceShellRc());
+    await CodifyCliSender.sendApplyNote(ApplyNotes.sourceShellRc());
   }
 
   /**
@@ -85,7 +85,7 @@ ${lines.join('\n')}`)
       await fs.appendFile(shellRc, `\nexport PATH=${value}:$PATH;`, { encoding: 'utf8' });
     }
 
-    CodifyCliSender.sendApplyNote(ApplyNotes.sourceShellRc());
+    await CodifyCliSender.sendApplyNote(ApplyNotes.sourceShellRc());
   }
 
   static async removeFromFile(filePath: string, search: string): Promise<void> {

package/src/utils/functions.ts

@@ -43,7 +43,7 @@ export function resolvePathWithVariables(pathWithVariables: string) {
 export function addVariablesToPath(pathWithoutVariables: string) {
   let result = pathWithoutVariables;
   for (const [key, value] of Object.entries(process.env)) {
-    if (!value || !path.isAbsolute(value) || value === '/' || value === homeDirectory || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
+    if (!value || !path.isAbsolute(value) || value === '/' || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
       continue;
     }