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

package/dist/entities/resource-options.js

@@ -0,0 +1,76 @@
+export class ResourceOptionsParser {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get statefulParameters() {
+        const statefulParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => p?.hasOwnProperty('statefulParameter'))
+            .map(([k, v]) => [k, v])
+            .map(([k, v]) => [k, v.statefulParameter]);
+        return new Map(statefulParameters);
+    }
+    get transformParameters() {
+        const transformParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => p?.hasOwnProperty('transformParameter'))
+            .map(([k, v]) => [k, v])
+            .map(([k, v]) => [k, v.transformParameter]);
+        return new Map(transformParameters);
+    }
+    get resourceParameters() {
+        const resourceParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => !(p?.hasOwnProperty('statefulParameter') || p?.hasOwnProperty('transformParameter')))
+            .map(([k, v]) => [k, v]);
+        return new Map(resourceParameters);
+    }
+    get changeSetParameterOptions() {
+        const resourceParameters = Object.fromEntries([...this.resourceParameters.entries()]
+            .map(([name, value]) => ([name, { ...value, isStatefulParameter: false }])));
+        const statefulParameters = [...this.statefulParameters.entries()]
+            ?.reduce((obj, sp) => ({
+            ...obj,
+            [sp[0]]: {
+                ...sp[1].options,
+                isStatefulParameter: true,
+            }
+        }), {});
+        return {
+            ...resourceParameters,
+            ...statefulParameters,
+        };
+    }
+    get defaultValues() {
+        if (!this.options.parameterOptions) {
+            return {};
+        }
+        return Object.fromEntries([...this.resourceParameters.entries()]
+            .filter(([, rp]) => rp.default !== undefined)
+            .map(([name, rp]) => [name, rp.default]));
+    }
+    get statefulParameterOrder() {
+        const entries = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, v]) => v?.hasOwnProperty('statefulParameter'))
+            .map(([k, v]) => [k, v]);
+        const orderedEntries = entries.filter(([, v]) => v.order !== undefined);
+        const unorderedEntries = entries.filter(([, v]) => v.order === undefined);
+        orderedEntries.sort((a, b) => a[1].order - b[1].order);
+        const resultArray = [
+            ...orderedEntries.map(([k]) => k),
+            ...unorderedEntries.map(([k]) => k)
+        ];
+        return new Map(resultArray.map((key, idx) => [key, idx]));
+    }
+    get transformParameterOrder() {
+        const entries = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, v]) => v?.hasOwnProperty('transformParameter'))
+            .map(([k, v]) => [k, v]);
+        const orderedEntries = entries.filter(([, v]) => v.order !== undefined);
+        const unorderedEntries = entries.filter(([, v]) => v.order === undefined);
+        orderedEntries.sort((a, b) => a[1].order - b[1].order);
+        const resultArray = [
+            ...orderedEntries.map(([k]) => k),
+            ...unorderedEntries.map(([k]) => k)
+        ];
+        return new Map(resultArray.map((key, idx) => [key, idx]));
+    }
+}

package/dist/entities/resource-types.d.ts

@@ -0,0 +1,11 @@
+export type ErrorMessage = string;
+export interface ResourceParameterOptions {
+    default?: unknown;
+    isEqual?: (desired: any, current: any) => boolean;
+    modifyOnChange?: boolean;
+}
+export interface ResourceDefinition {
+    [x: string]: {
+        type: string;
+    };
+}

package/dist/entities/resource-types.js

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

package/dist/entities/resource.d.ts

@@ -0,0 +1,42 @@
+import { Ajv, ValidateFunction } from 'ajv';
+import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
+import { ParameterChange } from './change-set.js';
+import { Plan } from './plan.js';
+import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions } from './plan-types.js';
+import { ResourceOptions } from './resource-options.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
+export declare abstract class Resource<T extends StringIndexedObject> {
+    readonly typeId: string;
+    readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+    readonly transformParameters: Map<keyof T, TransformParameter<T>>;
+    readonly resourceParameters: Map<keyof T, ResourceParameterOptions>;
+    readonly statefulParameterOrder: Map<keyof T, number>;
+    readonly transformParameterOrder: Map<keyof T, number>;
+    readonly dependencies: string[];
+    readonly parameterOptions: Record<keyof T, ParameterOptions>;
+    readonly options: ResourceOptions<T>;
+    readonly defaultValues: Partial<Record<keyof T, unknown>>;
+    protected ajv?: Ajv;
+    protected schemaValidator?: ValidateFunction;
+    protected constructor(options: ResourceOptions<T>);
+    onInitialize(): Promise<void>;
+    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
+    plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
+    apply(plan: Plan<T>): Promise<void>;
+    private _applyCreate;
+    private _applyModify;
+    private _applyDestroy;
+    private validateRefreshResults;
+    private applyTransformParameters;
+    private addDefaultValues;
+    private refreshNonStatefulParameters;
+    private refreshStatefulParameters;
+    private validatePlanInputs;
+    customValidation(parameters: Partial<T>): Promise<void>;
+    abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
+    abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
+    applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;
+    abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;
+}

package/dist/entities/resource.js

@@ -0,0 +1,303 @@
+import { Ajv } from 'ajv';
+import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
+import { setsEqual, splitUserConfig } from '../utils/utils.js';
+import { Plan } from './plan.js';
+import { ResourceOptionsParser } from './resource-options.js';
+export class Resource {
+    typeId;
+    statefulParameters;
+    transformParameters;
+    resourceParameters;
+    statefulParameterOrder;
+    transformParameterOrder;
+    dependencies;
+    parameterOptions;
+    options;
+    defaultValues;
+    ajv;
+    schemaValidator;
+    constructor(options) {
+        this.typeId = options.type;
+        this.dependencies = options.dependencies ?? [];
+        this.options = options;
+        if (this.options.schema) {
+            this.ajv = new Ajv({
+                allErrors: true,
+                strict: true,
+                strictRequired: false,
+            });
+            this.schemaValidator = this.ajv.compile(this.options.schema);
+        }
+        const parser = new ResourceOptionsParser(options);
+        this.statefulParameters = parser.statefulParameters;
+        this.transformParameters = parser.transformParameters;
+        this.resourceParameters = parser.resourceParameters;
+        this.parameterOptions = parser.changeSetParameterOptions;
+        this.defaultValues = parser.defaultValues;
+        this.statefulParameterOrder = parser.statefulParameterOrder;
+        this.transformParameterOrder = parser.transformParameterOrder;
+    }
+    async onInitialize() { }
+    async validate(parameters, resourceMetaData) {
+        if (this.schemaValidator) {
+            const isValid = this.schemaValidator(parameters);
+            if (!isValid) {
+                return {
+                    isValid: false,
+                    resourceName: resourceMetaData.name,
+                    resourceType: resourceMetaData.type,
+                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
+                };
+            }
+        }
+        let isValid = true;
+        let customValidationErrorMessage;
+        try {
+            await this.customValidation(parameters);
+        }
+        catch (error) {
+            isValid = false;
+            customValidationErrorMessage = error.message;
+        }
+        if (!isValid) {
+            return {
+                customValidationErrorMessage,
+                isValid: false,
+                resourceName: resourceMetaData.name,
+                resourceType: resourceMetaData.type,
+                schemaValidationErrors: this.schemaValidator?.errors ?? [],
+            };
+        }
+        return {
+            isValid: true,
+            resourceName: resourceMetaData.name,
+            resourceType: resourceMetaData.type,
+            schemaValidationErrors: [],
+        };
+    }
+    async plan(desiredConfig, currentConfig = null, statefulMode = false) {
+        this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
+        const planOptions = {
+            parameterOptions: this.parameterOptions,
+            statefulMode,
+        };
+        this.addDefaultValues(desiredConfig);
+        await this.applyTransformParameters(desiredConfig);
+        const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
+        const { desiredParameters, nonStatefulParameters, resourceMetadata, statefulParameters, } = parsedConfig;
+        const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
+        if (currentParameters === null || currentParameters === undefined) {
+            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
+        }
+        const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
+        return Plan.create(desiredParameters, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
+    }
+    async apply(plan) {
+        if (plan.getResourceType() !== this.typeId) {
+            throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
+        }
+        switch (plan.changeSet.operation) {
+            case ResourceOperation.CREATE: {
+                return this._applyCreate(plan);
+            }
+            case ResourceOperation.MODIFY: {
+                return this._applyModify(plan);
+            }
+            case ResourceOperation.RECREATE: {
+                await this._applyDestroy(plan);
+                return this._applyCreate(plan);
+            }
+            case ResourceOperation.DESTROY: {
+                return this._applyDestroy(plan);
+            }
+        }
+    }
+    async _applyCreate(plan) {
+        await this.applyCreate(plan);
+        const statefulParameterChanges = plan.changeSet.parameterChanges
+            .filter((pc) => this.statefulParameters.has(pc.name))
+            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.statefulParameters.get(parameterChange.name);
+            await statefulParameter.applyAdd(parameterChange.newValue, plan);
+        }
+    }
+    async _applyModify(plan) {
+        const parameterChanges = plan
+            .changeSet
+            .parameterChanges
+            .filter((c) => c.operation !== ParameterOperation.NOOP);
+        const statelessParameterChanges = parameterChanges
+            .filter((pc) => !this.statefulParameters.has(pc.name));
+        for (const pc of statelessParameterChanges) {
+            await this.applyModify(pc, plan);
+        }
+        const statefulParameterChanges = parameterChanges
+            .filter((pc) => this.statefulParameters.has(pc.name))
+            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.statefulParameters.get(parameterChange.name);
+            switch (parameterChange.operation) {
+                case ParameterOperation.ADD: {
+                    await statefulParameter.applyAdd(parameterChange.newValue, plan);
+                    break;
+                }
+                case ParameterOperation.MODIFY: {
+                    await statefulParameter.applyModify(parameterChange.newValue, parameterChange.previousValue, false, plan);
+                    break;
+                }
+                case ParameterOperation.REMOVE: {
+                    await statefulParameter.applyRemove(parameterChange.previousValue, plan);
+                    break;
+                }
+            }
+        }
+    }
+    async _applyDestroy(plan) {
+        if (this.options.callStatefulParameterRemoveOnDestroy) {
+            const statefulParameterChanges = plan.changeSet.parameterChanges
+                .filter((pc) => this.statefulParameters.has(pc.name))
+                .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
+            for (const parameterChange of statefulParameterChanges) {
+                const statefulParameter = this.statefulParameters.get(parameterChange.name);
+                await statefulParameter.applyRemove(parameterChange.previousValue, plan);
+            }
+        }
+        await this.applyDestroy(plan);
+    }
+    validateRefreshResults(refresh, desired) {
+        if (!refresh) {
+            return;
+        }
+        const desiredKeys = new Set(Object.keys(refresh));
+        const refreshKeys = new Set(Object.keys(refresh));
+        if (!setsEqual(desiredKeys, refreshKeys)) {
+            throw new Error(`Resource ${this.typeId}
+refresh() must return back exactly the keys that were provided
+Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
+Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
+        }
+    }
+    async applyTransformParameters(desired) {
+        if (!desired) {
+            return;
+        }
+        const transformParameters = [...this.transformParameters.entries()]
+            .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
+        for (const [key, transformParameter] of transformParameters) {
+            if (desired[key] === undefined) {
+                continue;
+            }
+            const transformedValue = await transformParameter.transform(desired[key]);
+            if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
+                throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
+            }
+            delete desired[key];
+            for (const [tvKey, tvValue] of Object.entries(transformedValue)) {
+                desired[tvKey] = tvValue;
+            }
+        }
+    }
+    addDefaultValues(desired) {
+        if (!desired) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
+            if (defaultValue !== undefined && desired[key] === undefined) {
+                desired[key] = defaultValue;
+            }
+        }
+    }
+    async refreshNonStatefulParameters(resourceParameters) {
+        const currentParameters = await this.refresh(resourceParameters);
+        this.validateRefreshResults(currentParameters, resourceParameters);
+        return currentParameters;
+    }
+    async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {
+        const currentParameters = {};
+        const sortedEntries = Object.entries(statefulParametersConfig)
+            .sort(([key1], [key2]) => this.statefulParameterOrder.get(key1) - this.statefulParameterOrder.get(key2));
+        for (const [key, desiredValue] of sortedEntries) {
+            const statefulParameter = this.statefulParameters.get(key);
+            if (!statefulParameter) {
+                throw new Error(`Stateful parameter ${key} was not found`);
+            }
+            let currentValue = await statefulParameter.refresh(desiredValue ?? null);
+            if (Array.isArray(currentValue)
+                && Array.isArray(desiredValue)
+                && !isStatefulMode
+                && !statefulParameter.options.disableStatelessModeArrayFiltering) {
+                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
+                    const parameterOptions = statefulParameter.options;
+                    if (parameterOptions && parameterOptions.isElementEqual) {
+                        return parameterOptions.isElementEqual(d, c);
+                    }
+                    return d === c;
+                }));
+            }
+            currentParameters[key] = currentValue;
+        }
+        return currentParameters;
+    }
+    validatePlanInputs(desired, current, statefulMode) {
+        if (!desired && !current) {
+            throw new Error('Desired config and current config cannot both be missing');
+        }
+        if (!statefulMode && !desired) {
+            throw new Error('Desired config must be provided in non-stateful mode');
+        }
+    }
+    async customValidation(parameters) { }
+    ;
+    async applyModify(pc, plan) { }
+    ;
+}
+class ConfigParser {
+    desiredConfig;
+    currentConfig;
+    statefulParametersMap;
+    transformParametersMap;
+    constructor(desiredConfig, currentConfig, statefulParameters, transformParameters) {
+        this.desiredConfig = desiredConfig;
+        this.currentConfig = currentConfig;
+        this.statefulParametersMap = statefulParameters;
+        this.transformParametersMap = transformParameters;
+    }
+    get resourceMetadata() {
+        const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
+        const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
+        if (!desiredMetadata && !currentMetadata) {
+            throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`);
+        }
+        if (currentMetadata && desiredMetadata && (Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
+            || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value))) {
+            throw new Error(`The metadata for the current config does not match the desired config. 
+Desired metadata:
+${JSON.stringify(desiredMetadata, null, 2)}
+
+Current metadata:
+${JSON.stringify(currentMetadata, null, 2)}`);
+        }
+        return desiredMetadata ?? currentMetadata;
+    }
+    get desiredParameters() {
+        if (!this.desiredConfig) {
+            return null;
+        }
+        const { parameters } = splitUserConfig(this.desiredConfig);
+        return parameters;
+    }
+    get parameters() {
+        const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
+        const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
+        return { ...desiredParameters, ...currentParameters };
+    }
+    get nonStatefulParameters() {
+        const { parameters } = this;
+        return Object.fromEntries(Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))));
+    }
+    get statefulParameters() {
+        const { parameters } = this;
+        return Object.fromEntries(Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)));
+    }
+}

package/dist/entities/stateful-parameter.d.ts

@@ -0,0 +1,29 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
+export interface StatefulParameterOptions<V> {
+    isEqual?: (desired: any, current: any) => boolean;
+    disableStatelessModeArrayFiltering?: boolean;
+    default?: V;
+}
+export interface ArrayStatefulParameterOptions<V> extends StatefulParameterOptions<V> {
+    isEqual?: (desired: any[], current: any[]) => boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
+}
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    readonly options: StatefulParameterOptions<V>;
+    constructor(options?: StatefulParameterOptions<V>);
+    abstract refresh(desired: V | null): Promise<V | null>;
+    abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    options: ArrayStatefulParameterOptions<V>;
+    constructor(options?: ArrayStatefulParameterOptions<V>);
+    applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    abstract refresh(desired: V[] | null): Promise<V[] | null>;
+    abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
+    abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
+}

package/dist/entities/stateful-parameter.js

@@ -0,0 +1,46 @@
+export class StatefulParameter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+}
+export class ArrayStatefulParameter extends StatefulParameter {
+    options;
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+    }
+    async applyAdd(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.applyAddItem(value, plan);
+        }
+    }
+    async applyModify(newValues, previousValues, allowDeletes, plan) {
+        const options = this.options;
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if (options.isElementEqual) {
+                return options.isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if (options.isElementEqual) {
+                return options.isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        for (const value of valuesToAdd) {
+            await this.applyAddItem(value, plan);
+        }
+        if (allowDeletes) {
+            for (const value of valuesToRemove) {
+                await this.applyRemoveItem(value, plan);
+            }
+        }
+    }
+    async applyRemove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.applyRemoveItem(value, plan);
+        }
+    }
+}

package/dist/entities/transform-parameter.d.ts

@@ -0,0 +1,4 @@
+import { StringIndexedObject } from 'codify-schemas';
+export declare abstract class TransformParameter<T extends StringIndexedObject> {
+    abstract transform(value: any): Promise<Partial<T>>;
+}

package/dist/entities/transform-parameter.js

@@ -0,0 +1,2 @@
+export class TransformParameter {
+}

package/dist/plan/change-set.d.ts

@@ -49,6 +49,6 @@ export declare class ChangeSet<T extends StringIndexedObject> {
      */
     private static calculateParameterChanges;
     private static combineResourceOperations;
-    private static isAbsent;
+    static isAbsent(v: unknown): boolean;
     private static isSame;
 }

package/dist/plan/plan.js

@@ -55,13 +55,24 @@ export class Plan {
             settings,
             isStateful
         });
-        const filteredCurrentParameters = Plan.filterCurrentParams({
+        let filteredCurrentParameters = Plan.filterCurrentParams({
             desired,
             current,
             state,
             settings,
             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(uuidV4(), ChangeSet.empty(), core, isStateful);

package/dist/pty/background-pty.js

@@ -18,7 +18,10 @@ EventEmitter.defaultMaxListeners = 1000;
  */
 export class BackgroundPty {
     historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
-    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.
+    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),
@@ -128,6 +131,6 @@ export class BackgroundPty {
         return [];
     }
     getDefaultShell() {
-        return process.env.SHELL;
+        return Utils.getDefaultShell();
     }
 }

package/dist/pty/seqeuntial-pty.js

@@ -70,7 +70,11 @@ export class SequentialPty {
             // 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, {
                 ...options,
@@ -134,6 +138,6 @@ export class SequentialPty {
         });
     }
     getDefaultShell() {
-        return process.env.SHELL;
+        return Utils.getDefaultShell();
     }
 }

package/dist/pty/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/pty/vitest.config.js

@@ -0,0 +1,11 @@
+import { defaultExclude, defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        pool: 'forks',
+        fileParallelism: false,
+        exclude: [
+            ...defaultExclude,
+            './src/utils/test-utils.test.ts',
+        ]
+    },
+});