codify-plugin-lib 1.0.182-beta1 → 1.0.182-beta11

package/dist/index.d.ts

@@ -10,5 +10,8 @@ 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 declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -10,7 +10,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 async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));

package/dist/plugin/plugin.js

@@ -4,8 +4,8 @@ import { BackgroundPty } from '../pty/background-pty.js';
 import { getPty } from '../pty/index.js';
 import { SequentialPty } from '../pty/seqeuntial-pty.js';
 import { ResourceController } from '../resource/resource-controller.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
 export class Plugin {
     name;
     resourceControllers;

package/dist/pty/background-pty.d.ts

@@ -6,6 +6,7 @@ import { IPty, SpawnOptions, SpawnResult } from './index.js';
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export declare class BackgroundPty implements IPty {
+    private historyIgnore;
     private basePty;
     private promiseQueue;
     constructor();

package/dist/pty/background-pty.js

@@ -6,7 +6,6 @@ import * as fs from 'node:fs/promises';
 import stripAnsi from 'strip-ansi';
 import { debugLog } from '../utils/debug.js';
 import { Shell, Utils } from '../utils/index.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
 import { SpawnError } from './index.js';
 import { PromiseQueue } from './promise-queue.js';
 EventEmitter.defaultMaxListeners = 1000;
@@ -17,8 +16,10 @@ EventEmitter.defaultMaxListeners = 1000;
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export class BackgroundPty {
+    historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
     basePty = pty.spawn(this.getDefaultShell(), ['-i'], {
-        env: process.env, name: nanoid(6),
+        env: { ...process.env, ...this.historyIgnore },
+        name: nanoid(6),
         handleFlowControl: true
     });
     promiseQueue = new PromiseQueue();
@@ -65,9 +66,9 @@ export class BackgroundPty {
                 }
                 else {
                     // Print to stdout if the verbosity level is above 0
-                    if (VerbosityLevel.get() > 0) {
-                        process.stdout.write(data);
-                    }
+                    // if (VerbosityLevel.get() > 0) {
+                    //   process.stdout.write(data);
+                    // }
                 }
             });
             this.promiseQueue.run(async () => new Promise((resolve) => {
@@ -105,16 +106,17 @@ export class BackgroundPty {
             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;
-                    }
-                }
+                // 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/dist/pty/index.d.ts

@@ -26,6 +26,8 @@ export interface SpawnOptions {
     cwd?: string;
     env?: Record<string, unknown>;
     interactive?: boolean;
+    requiresRoot?: boolean;
+    stdin?: boolean;
 }
 export declare class SpawnError extends Error {
     data: string;

package/dist/pty/seqeuntial-pty.d.ts

@@ -12,5 +12,6 @@ export declare class SequentialPty implements IPty {
         exitCode: number;
         signal?: number | undefined;
     }>;
+    externalSpawn(cmd: string, opts: SpawnOptions): Promise<SpawnResult>;
     private getDefaultShell;
 }

package/dist/pty/seqeuntial-pty.js

@@ -1,10 +1,17 @@
 import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { Ajv } from 'ajv';
+import { CommandRequestResponseDataSchema, MessageCmd } from 'codify-schemas';
+import { nanoid } from 'nanoid';
 import { EventEmitter } from 'node:events';
 import stripAnsi from 'strip-ansi';
 import { Shell, Utils } from '../utils/index.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
 import { SpawnError, SpawnStatus } from './index.js';
 EventEmitter.defaultMaxListeners = 1000;
+const ajv = new Ajv({
+    strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(CommandRequestResponseDataSchema);
 /**
  * The background pty is a specialized pty designed for speed. It can launch multiple tasks
  * in parallel by moving them to the background. It attaches unix FIFO pipes to each process
@@ -20,6 +27,13 @@ export class SequentialPty {
         return spawnResult;
     }
     async spawnSafe(cmd, options) {
+        if (cmd.includes('sudo')) {
+            throw new Error('Do not directly use sudo. Use the option { requiresRoot: true } instead');
+        }
+        // If sudo is required, we must delegate to the main codify process.
+        if (options?.stdin || options?.requiresRoot) {
+            return this.externalSpawn(cmd, options);
+        }
         console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
         return new Promise((resolve) => {
             const output = [];
@@ -30,12 +44,13 @@ export class SequentialPty {
                 ...process.env, ...options?.env,
                 TERM_PROGRAM: 'codify',
                 COMMAND_MODE: 'unix2003',
-                COLORTERM: 'truecolor', ...historyIgnore
+                COLORTERM: 'truecolor',
+                ...historyIgnore
             };
             // Initial terminal dimensions
             const initialCols = process.stdout.columns ?? 80;
             const initialRows = process.stdout.rows ?? 24;
-            const args = (options?.interactive ?? true) ? ['-i', '-c', `"${cmd}"`] : ['-c', `"${cmd}"`];
+            const args = options?.interactive ? ['-i', '-c', cmd] : ['-c', cmd];
             // Run the command in a pty for interactivity
             const mPty = pty.spawn(this.getDefaultShell(), args, {
                 ...options,
@@ -49,20 +64,14 @@ export class SequentialPty {
                 }
                 output.push(data.toString());
             });
-            const stdinListener = (data) => {
-                mPty.write(data.toString());
-            };
             const resizeListener = () => {
                 const { columns, rows } = process.stdout;
                 mPty.resize(columns, rows);
             };
             // Listen to resize events for the terminal window;
             process.stdout.on('resize', resizeListener);
-            // Listen for user input
-            process.stdin.on('data', stdinListener);
             mPty.onExit((result) => {
                 process.stdout.off('resize', resizeListener);
-                process.stdin.off('data', stdinListener);
                 resolve({
                     status: result.exitCode === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
                     exitCode: result.exitCode,
@@ -78,6 +87,30 @@ export class SequentialPty {
             signal: 0,
         };
     }
+    // For safety reasons, requests that require sudo or are interactive must be run via the main client
+    async externalSpawn(cmd, opts) {
+        return new Promise((resolve) => {
+            const requestId = nanoid(8);
+            const listener = (data) => {
+                if (data.requestId === requestId) {
+                    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.COMMAND_REQUEST,
+                data: {
+                    command: cmd,
+                    options: opts ?? {},
+                },
+                requestId
+            });
+        });
+    }
     getDefaultShell() {
         return process.env.SHELL;
     }

package/dist/resource/resource-settings.js

@@ -1,6 +1,6 @@
 import isObjectsEqual from 'lodash.isequal';
 import path from 'node:path';
-import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/internal-utils.js';
+import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/functions.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => {

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+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 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

@@ -0,0 +1,172 @@
+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 addToStartupFile(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 addAllToStartupFile(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) {
+        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 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, '');
+        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 removeLineFromPrimaryShellRc(search) {
+        return 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;
+    }
+    // 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.d.ts

@@ -0,0 +1,12 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+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/functions.js

@@ -0,0 +1,74 @@
+import os from 'node:os';
+import path from 'node:path';
+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/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { OS } from 'codify-schemas';
+export declare function isDebug(): boolean;
 export declare enum Shell {
     ZSH = "zsh",
     BASH = "bash",

package/dist/utils/index.js

@@ -1,5 +1,8 @@
 import os from 'node:os';
 import path from 'node:path';
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
 export var Shell;
 (function (Shell) {
     Shell["ZSH"] = "zsh";

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

@@ -1,10 +1,4 @@
 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;

package/dist/utils/internal-utils.js

@@ -1,17 +1,5 @@
 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,

package/dist/utils/verbosity-level.d.ts

@@ -0,0 +1,5 @@
+export declare const VerbosityLevel: {
+    level: number;
+    get(): number;
+    set(level: number): void;
+};

package/dist/utils/verbosity-level.js

@@ -0,0 +1,9 @@
+export const VerbosityLevel = new class {
+    level = 0;
+    get() {
+        return this.level;
+    }
+    set(level) {
+        this.level = level;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta1",
+  "version": "1.0.182-beta11",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "clean-deep": "^3.4.0",
-    "codify-schemas": "1.0.86",
+    "codify-schemas": "1.0.86-beta5",
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",

package/src/index.ts

@@ -12,7 +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 async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);

package/src/plugin/plugin.ts

@@ -24,8 +24,8 @@ 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 { VerbosityLevel } from '../utils/internal-utils.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
 
 export class Plugin {
   planStorage: Map<string, Plan<any>>;

package/src/pty/background-pty.ts

@@ -7,7 +7,7 @@ import stripAnsi from 'strip-ansi';
 
 import { debugLog } from '../utils/debug.js';
 import { Shell, Utils } from '../utils/index.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
 import { IPty, SpawnError, SpawnOptions, SpawnResult } from './index.js';
 import { PromiseQueue } from './promise-queue.js';
 
@@ -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
   });
 
@@ -79,9 +81,9 @@ export class BackgroundPty implements IPty {
           });
         } else {
           // Print to stdout if the verbosity level is above 0
-          if (VerbosityLevel.get() > 0) {
-            process.stdout.write(data);
-          }
+          // if (VerbosityLevel.get() > 0) {
+          //   process.stdout.write(data);
+          // }
         }
       })
 
@@ -129,17 +131,17 @@ export class BackgroundPty implements IPty {
 
       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;
-          }
-        }
+        // 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')

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 {

package/src/pty/seqeuntial-pty.ts

@@ -1,13 +1,21 @@
 import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { Ajv } from 'ajv';
+import { CommandRequestResponseData, CommandRequestResponseDataSchema, IpcMessageV2, MessageCmd } from 'codify-schemas';
+import { nanoid } from 'nanoid';
 import { EventEmitter } from 'node:events';
 import stripAnsi from 'strip-ansi';
 
 import { Shell, Utils } from '../utils/index.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
 import { IPty, SpawnError, SpawnOptions, SpawnResult, SpawnStatus } from './index.js';
 
 EventEmitter.defaultMaxListeners = 1000;
 
+const ajv = new Ajv({
+  strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(CommandRequestResponseDataSchema);
+
 /**
  * The background pty is a specialized pty designed for speed. It can launch multiple tasks
  * in parallel by moving them to the background. It attaches unix FIFO pipes to each process
@@ -26,11 +34,19 @@ export class SequentialPty implements IPty {
   }
 
   async spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult> {
+    if (cmd.includes('sudo')) {
+      throw new Error('Do not directly use sudo. Use the option { requiresRoot: true } instead')
+    }
+
+    // If sudo is required, we must delegate to the main codify process.
+    if (options?.stdin || options?.requiresRoot) {
+      return this.externalSpawn(cmd, options);
+    }
+
     console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''))
 
     return new Promise((resolve) => {
       const output: string[] = [];
-
       const historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
 
       // If TERM_PROGRAM=Apple_Terminal is set then ANSI escape characters may be included
@@ -39,14 +55,15 @@ export class SequentialPty implements IPty {
         ...process.env, ...options?.env,
         TERM_PROGRAM: 'codify',
         COMMAND_MODE: 'unix2003',
-        COLORTERM: 'truecolor', ...historyIgnore
+        COLORTERM: 'truecolor',
+        ...historyIgnore
       }
 
       // Initial terminal dimensions
       const initialCols = process.stdout.columns ?? 80;
       const initialRows = process.stdout.rows ?? 24;
 
-      const args = (options?.interactive ?? true) ? ['-i', '-c', `"${cmd}"`] : ['-c', `"${cmd}"`]
+      const args = options?.interactive ? ['-i', '-c', cmd] : ['-c', cmd]
 
       // Run the command in a pty for interactivity
       const mPty = pty.spawn(this.getDefaultShell(), args, {
@@ -64,10 +81,6 @@ export class SequentialPty implements IPty {
         output.push(data.toString());
       })
 
-      const stdinListener = (data: any) => {
-        mPty.write(data.toString());
-      };
-
       const resizeListener = () => {
         const { columns, rows } = process.stdout;
         mPty.resize(columns, rows);
@@ -75,12 +88,9 @@ export class SequentialPty implements IPty {
 
       // Listen to resize events for the terminal window;
       process.stdout.on('resize', resizeListener);
-      // Listen for user input
-      process.stdin.on('data', stdinListener);
 
       mPty.onExit((result) => {
         process.stdout.off('resize', resizeListener);
-        process.stdin.off('data', stdinListener);
 
         resolve({
           status: result.exitCode === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
@@ -99,6 +109,39 @@ export class SequentialPty implements IPty {
     }
   }
 
+  // For safety reasons, requests that require sudo or are interactive must be run via the main client
+  async externalSpawn(
+    cmd: string,
+    opts: SpawnOptions
+  ): Promise<SpawnResult> {
+    return new Promise((resolve) => {
+      const requestId = nanoid(8);
+
+      const listener = (data: IpcMessageV2) => {
+        if (data.requestId === requestId) {
+          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 as unknown as CommandRequestResponseData);
+        }
+      }
+
+      process.on('message', listener);
+
+      process.send!(<IpcMessageV2>{
+        cmd: MessageCmd.COMMAND_REQUEST,
+        data: {
+          command: cmd,
+          options: opts ?? {},
+        },
+        requestId
+      })
+    });
+  }
+
   private getDefaultShell(): string {
     return process.env.SHELL!;
   }

package/src/pty/sequential-pty.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { SequentialPty } from './seqeuntial-pty.js';
-import { VerbosityLevel } from '../utils/internal-utils.js';
+import { VerbosityLevel } from '../utils/verbosity-level.js';
+import { MessageStatus, SpawnStatus } from 'codify-schemas/src/types/index.js';
+import { IpcMessageV2, MessageCmd } from 'codify-schemas';
 
 describe('SequentialPty tests', () => {
   it('Can launch a simple command', async () => {
@@ -33,8 +35,8 @@ describe('SequentialPty tests', () => {
     const resultFailed = await pty.spawnSafe('which sjkdhsakjdhjkash');
     expect(resultFailed).toMatchObject({
       status: 'error',
-      exitCode: 127,
-      data: 'zsh:1: command not found: which sjkdhsakjdhjkash' // This might change on different os or shells. Keep for now.
+      exitCode: 1,
+      data: 'sjkdhsakjdhjkash not found' // This might change on different os or shells. Keep for now.
     })
   });
 
@@ -50,12 +52,128 @@ describe('SequentialPty tests', () => {
   });
 
   it('It can launch a command in interactive mode', async () => {
-    const pty = new SequentialPty();
+    const originalSend = process.send;
+    process.send = (req: IpcMessageV2) => {
+      expect(req).toMatchObject({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: expect.any(String),
+        data: {
+          command: 'ls',
+          options: {
+            cwd: '/tmp',
+            interactive: true,
+          }
+        }
+      })
+
+      // This may look confusing but what we're doing here is directly finding the process listener and calling it without going through serialization
+      const listeners = process.listeners('message');
+      listeners[2](({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: req.requestId,
+        status: MessageStatus.SUCCESS,
+        data: {
+          status: SpawnStatus.SUCCESS,
+          exitCode: 0,
+          data: 'My data',
+        }
+      }))
+
+      return true;
+    }
+
+    const $ = new SequentialPty();
+    const resultSuccess = await $.spawnSafe('ls', { interactive: true, cwd: '/tmp' });
 
-    const resultSuccess = await pty.spawnSafe('ls', { interactive: false });
     expect(resultSuccess).toMatchObject({
       status: 'success',
       exitCode: 0,
-    })
+    });
+
+    process.send = originalSend;
   });
+
+  it('It can work with root (sudo)', async () => {
+    const originalSend = process.send;
+    process.send = (req: IpcMessageV2) => {
+      expect(req).toMatchObject({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: expect.any(String),
+        data: {
+          command: 'ls',
+          options: {
+            interactive: true,
+            requiresRoot: true,
+          }
+        }
+      })
+
+      // This may look confusing but what we're doing here is directly finding the process listener and calling it without going through serialization
+      const listeners = process.listeners('message');
+      listeners[2](({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: req.requestId,
+        status: MessageStatus.SUCCESS,
+        data: {
+          status: SpawnStatus.SUCCESS,
+          exitCode: 0,
+          data: 'My data',
+        }
+      }))
+
+      return true;
+    }
+
+    const $ = new SequentialPty();
+    const resultSuccess = await $.spawn('ls', { interactive: true, requiresRoot: true });
+
+    expect(resultSuccess).toMatchObject({
+      status: 'success',
+      exitCode: 0,
+    });
+
+    process.send = originalSend;
+  })
+
+  it('It can handle errors when in sudo', async () => {
+    const originalSend = process.send;
+    process.send = (req: IpcMessageV2) => {
+      expect(req).toMatchObject({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: expect.any(String),
+        data: {
+          command: 'ls',
+          options: {
+            requiresRoot: true,
+            interactive: true,
+          }
+        }
+      })
+
+      // This may look confusing but what we're doing here is directly finding the process listener and calling it without going through serialization
+      const listeners = process.listeners('message');
+      listeners[2](({
+        cmd: MessageCmd.COMMAND_REQUEST,
+        requestId: req.requestId,
+        status: MessageStatus.SUCCESS,
+        data: {
+          status: SpawnStatus.ERROR,
+          exitCode: 127,
+          data: 'My data',
+        }
+      }))
+
+      return true;
+    }
+
+    const $ = new SequentialPty();
+    const resultSuccess = await $.spawnSafe('ls', { interactive: true, requiresRoot: true });
+
+    expect(resultSuccess).toMatchObject({
+      status: SpawnStatus.ERROR,
+      exitCode: 127,
+    });
+
+    process.send = originalSend;
+  })
 })

package/src/resource/resource-controller.test.ts

@@ -7,7 +7,7 @@ import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
 import { ParameterChange } from '../plan/change-set.js';
 import { ResourceController } from './resource-controller.js';
 import { TestConfig, testPlan, TestResource, TestStatefulParameter } from '../utils/test-utils.test.js';
-import { tildify, untildify } from '../utils/internal-utils.js';
+import { tildify, untildify } from '../utils/functions.js';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { Plan } from '../plan/plan.js';
 import os from 'node:os';

package/src/resource/resource-settings.ts

@@ -10,7 +10,7 @@ import {
   resolvePathWithVariables,
   tildify,
   untildify
-} from '../utils/internal-utils.js';
+} from '../utils/functions.js';
 import { RefreshContext } from './resource.js';
 
 export interface InputTransformation {

package/src/utils/file-utils.test.ts

@@ -0,0 +1,7 @@
+import { describe, it } from 'vitest';
+
+describe('File utils tests', { timeout: 100_000_000 }, () => {
+  it('Can download a file', async () => {
+    // await FileUtils.downloadFile('https://download.jetbrains.com/webstorm/WebStorm-2025.3.1-aarch64.dmg?_gl=1*1huoi7o*_gcl_aw*R0NMLjE3NjU3NDAwMTcuQ2p3S0NBaUEzZm5KQmhBZ0Vpd0F5cW1ZNVhLVENlbHJOcTk2YXdjZVlfMS1wdE91MXc0WDk2bFJkVDM3QURhUFNJMUtwNVVSVUhxWTJob0NuZ0FRQXZEX0J3RQ..*_gcl_au*MjA0MDQ0MjE2My4xNzYzNjQzNzMz*FPAU*MjA0MDQ0MjE2My4xNzYzNjQzNzMz*_ga*MTYxMDg4MTkzMi4xNzYzNjQzNzMz*_ga_9J976DJZ68*czE3NjYzNjI5ODAkbzEyJGcxJHQxNzY2MzYzMDQwJGo2MCRsMCRoMA..', path.join(process.cwd(), 'google.html'));
+  })
+})

package/src/utils/file-utils.ts

@@ -0,0 +1,216 @@
+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: string, destination: string): Promise<void> {
+    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 as never).pipe(ws));
+
+    console.log(`Finished downloading to ${destination}`);
+  }
+
+  static async addToStartupFile(line: string): Promise<void> {
+    const lineToInsert = addLeadingSpacer(
+      addTrailingSpacer(line)
+    );
+
+    await fs.appendFile(Utils.getPrimaryShellRc(), lineToInsert)
+
+    function addLeadingSpacer(line: string): string {
+      return line.startsWith('\n')
+        ? line
+        : '\n' + line;
+    }
+
+    function addTrailingSpacer(line: string): string {
+      return line.endsWith('\n')
+        ? line
+        : line + '\n';
+    }
+  }
+
+  static async addAllToStartupFile(lines: string[]): Promise<void> {
+    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: string, prepend: boolean): Promise<void> {
+    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 dirExists(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  static async fileExists(path: string): Promise<boolean> {
+    let stat;
+    try {
+      stat = await fs.stat(path);
+      return stat.isFile();
+    } catch {
+      return false;
+    }
+  }
+
+  static async exists(path: string): Promise<boolean> {
+    try {
+      await fs.stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static async checkDirExistsOrThrowIfFile(path: string): Promise<boolean> {
+    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: string): Promise<void> {
+    if (!fsSync.existsSync(path)) {
+      await fs.mkdir(path, { recursive: true });
+    }
+  }
+
+  static async removeFromFile(filePath: string, search: string): Promise<void> {
+    const contents = await fs.readFile(filePath, 'utf8');
+    const newContents = contents.replaceAll(search, '');
+
+    await fs.writeFile(filePath, newContents, 'utf8');
+  }
+
+
+  static async removeLineFromFile(filePath: string, search: RegExp | string): Promise<void> {
+    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 removeLineFromPrimaryShellRc(search: RegExp | string): Promise<void> {
+    return 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: string, textToInsert: string): string {
+    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
+  }
+
+  // This is overly complicated but it can be used to insert into any
+  // position in the future
+  private static calculateEndingNewLines(lines: string[]): number {
+    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/src/utils/{internal-utils.ts → functions.ts}

@@ -2,22 +2,6 @@ import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 import os from 'node:os';
 import path from 'node:path';
 
-export const VerbosityLevel = new class {
-  level = 0;
-
-  get() {
-    return this.level;
-  }
-
-  set(level: number) {
-    this.level = level;
-  }
-}
-
-export function isDebug(): boolean {
-  return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
-}
-
 export function splitUserConfig<T extends StringIndexedObject>(
   config: ResourceConfig & T
 ): { parameters: T; coreParameters: ResourceConfig } {

package/src/utils/index.ts

@@ -2,6 +2,10 @@ import { OS } from 'codify-schemas';
 import os from 'node:os';
 import path from 'node:path';
 
+export function isDebug(): boolean {
+  return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
+
 export enum Shell {
   ZSH = 'zsh',
   BASH = 'bash',

package/src/utils/internal-utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { addVariablesToPath, resolvePathWithVariables, splitUserConfig } from './internal-utils.js';
+import { addVariablesToPath, resolvePathWithVariables, splitUserConfig } from './functions.js';
 import os from 'node:os';
 
 describe('Utils tests', () => {

package/src/utils/verbosity-level.ts

@@ -0,0 +1,11 @@
+export const VerbosityLevel = new class {
+  level = 0;
+
+  get() {
+    return this.level;
+  }
+
+  set(level: number) {
+    this.level = level;
+  }
+}