@codifycli/plugin-core 1.2.5-beta.3 → 1.2.5-beta.4

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/dist/utils/spawn-2.d.ts

@@ -0,0 +1,5 @@
+import { Shell } from 'zx';
+export declare class ShellContext implements Shell {
+    zx: Shell;
+    static create(): ShellContext;
+}

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.5-beta.3",
+  "version": "1.2.5-beta.4",
   "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/plan/change-set.ts

@@ -227,7 +227,7 @@ export class ChangeSet<T extends StringIndexedObject> {
     return orderOfOperations[Math.max(indexPrev, indexNext)];
   }
 
-  private static isAbsent(v: unknown): boolean {
+  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;

package/src/plan/plan.test.ts

@@ -226,6 +226,39 @@ describe('Plan entity tests', () => {
     })
   })
 
+  it('Treats an empty-after-filtering array as no current state (already destroyed)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propZ: { type: 'array', isElementEqual: (a, b) => a === b }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        // The declared item is already gone from the system, but other unrelated items remain —
+        // refresh() can't know which items belong to this resource's declared config, so it still
+        // returns a non-empty object overall.
+        return {
+          propZ: ['some-other-unmanaged-item']
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(
+      { type: 'type' },
+      null,
+      { propZ: ['20.15.0'] } as any,
+      true
+    )
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
   it('Doesn\'t filters array parameters if filtering is disabled', async () => {
     const resource = new class extends TestResource {
       getSettings(): ResourceSettings<any> {

package/src/plan/plan.ts

@@ -96,7 +96,7 @@ export class Plan<T extends StringIndexedObject> {
       isStateful
     });
 
-    const filteredCurrentParameters = Plan.filterCurrentParams<T>({
+    let filteredCurrentParameters = Plan.filterCurrentParams<T>({
       desired,
       current,
       state,
@@ -104,6 +104,18 @@ export class Plan<T extends StringIndexedObject> {
       isStateful
     });
 
+    // A filtered result with at least one key, where every value is absent (empty array/object, null,
+    // undefined), carries no actionable state — treat it the same as no current parameters at all.
+    // This matters for resources managing an internal array (e.g. multiple declarations in one
+    // resource instance) where destroy-time filtering can legitimately narrow the array down to []
+    // once every declared item has been removed, without the resource itself disappearing from
+    // filteredCurrentParams. An empty object ({}, zero keys) is intentionally excluded — per the
+    // refresh() contract, {} means "exists with no state to track", distinct from "doesn't exist".
+    const filteredEntries = filteredCurrentParameters ? Object.values(filteredCurrentParameters) : [];
+    if (filteredCurrentParameters && filteredEntries.length > 0 && filteredEntries.every((v) => ChangeSet.isAbsent(v))) {
+      filteredCurrentParameters = null;
+    }
+
     // Empty
     if (!filteredCurrentParameters && !desired) {
       return new Plan(

package/src/pty/background-pty.ts

@@ -21,7 +21,10 @@ EventEmitter.defaultMaxListeners = 1000;
  */
 export class BackgroundPty implements IPty {
   private historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
-  private basePty = pty.spawn(this.getDefaultShell(), ['-i'], {
+  // Login + interactive (-l -i) so the user's rc files are sourced. GUI launches
+  // (e.g. the Codify desktop app) do not inherit env like TART_HOME / PATH additions
+  // from the parent process; these live in ~/.zshrc / ~/.zprofile.
+  private basePty = pty.spawn(this.getDefaultShell(), ['-l', '-i'], {
     env: { ...process.env, ...this.historyIgnore },
     cols: 10_000, // Set to a really large value to prevent wrapping
     name: nanoid(6),
@@ -156,6 +159,6 @@ export class BackgroundPty implements IPty {
   }
 
   private getDefaultShell(): string {
-    return process.env.SHELL!;
+    return Utils.getDefaultShell();
   }
 }

package/src/pty/seqeuntial-pty.ts

@@ -92,7 +92,11 @@ export class SequentialPty implements IPty {
       // the pty waiting for interactive input. Can't be disabled via env var; must unset the options explicitly.
       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]
+      // Use a login + interactive shell (-l -i) so the user's rc files are sourced.
+      // This matters for GUI launches (e.g. the Codify desktop app) where env vars
+      // like TART_HOME and PATH additions live in ~/.zshrc/~/.zprofile and are not
+      // inherited from the parent process.
+      const args = options?.interactive ? ['-l', '-i', '-c', wrappedCmd] : ['-c', wrappedCmd]
 
       // Run the command in a pty for interactivity
       const mPty = pty.spawn(this.getDefaultShell(), args, {
@@ -175,6 +179,6 @@ export class SequentialPty implements IPty {
   }
 
   private getDefaultShell(): string {
-    return process.env.SHELL!;
+    return Utils.getDefaultShell();
   }
 }

package/src/utils/index.ts

@@ -132,6 +132,20 @@ export const Utils = {
     return undefined;
   },
 
+  /**
+   * Resolves the shell binary to launch commands with. `process.env.SHELL` is
+   * only set when Codify is launched from a terminal — GUI launches (e.g. the
+   * Codify desktop app via launchd) do not export it, in which case
+   * `node-pty` would fall back to `/bin/sh`, which does not source the user's
+   * `~/.zshrc`/`~/.bash_profile`. That drops user env (e.g. TART_HOME, PATH
+   * additions), breaking resource refresh. Fall back to the login shell from
+   * the passwd database (os.userInfo().shell) so we always use the user's real
+   * shell regardless of how Codify was started.
+   */
+  getDefaultShell(): string {
+    return process.env.SHELL || os.userInfo().shell || '/bin/zsh';
+  },
+
 
   getPrimaryShellRc(): string {
     return this.getShellRcFiles()[0];
@@ -244,7 +258,10 @@ Brew can be installed using Codify:
       if (brewOpts?.adopt) flags.push('--adopt');
       if (brewOpts?.flags) flags.push(...brewOpts.flags);
       const flagStr = flags.length > 0 ? `${flags.join(' ')} ` : '';
-      await $.spawn(`brew install ${flagStr}${packageName}`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1, HOMEBREW_NO_ASK: 1 } });
+      // Redirect stdin from /dev/null so Homebrew's ask.rb detects a non-TTY stdin
+      // and skips any [y/n] confirmation prompts (e.g. "Do you want to proceed with the installation?").
+      // NONINTERACTIVE=1 alone is not sufficient — Homebrew's prompt only checks tty?, not that var.
+      await $.spawn(`brew install ${flagStr}${packageName} < /dev/null`, { interactive: true, env: { HOMEBREW_NO_AUTO_UPDATE: 1, NONINTERACTIVE: 1 } });
       return;
     }
 
@@ -350,7 +367,7 @@ Brew can be installed using Codify:
       const flagStr = flags.length > 0 ? `${flags.join(' ')} ` : '';
       const { status } = await $.spawnSafe(`brew uninstall ${flagStr}${packageName}`, {
         interactive: true,
-        env: { HOMEBREW_NO_AUTO_UPDATE: 1, HOMEBREW_NO_ASK: 1 }
+        env: { HOMEBREW_NO_AUTO_UPDATE: 1, NONINTERACTIVE: 1 }
       });
       return status === SpawnStatus.SUCCESS;
     }