codify-plugin-lib 1.0.182-beta7 → 1.0.182-beta71

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/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.
     })
   });
 
@@ -49,13 +51,144 @@ describe('SequentialPty tests', () => {
     })
   });
 
-  it('It can launch a command in interactive mode', async () => {
+
+  it('Can use multi-line commands', async () => {
     const pty = new SequentialPty();
 
-    const resultSuccess = await pty.spawnSafe('ls', { interactive: true });
+    const resultSuccess = await pty.spawnSafe([
+      'pwd',
+      '&& ls',
+    ], { cwd: '/tmp' });
     expect(resultSuccess).toMatchObject({
       status: 'success',
       exitCode: 0,
     })
   });
+
+
+  it('It can launch a command in interactive mode', async () => {
+    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' });
+
+    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/parsed-resource-settings.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { ResourceSettings } from './resource-settings.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { TestConfig } from '../utils/test-utils.test.js';
+import { z } from 'zod';
+import { OS } from 'codify-schemas';
 
 describe('Resource options parser tests', () => {
   it('Parses default values from options', () => {
@@ -159,4 +161,26 @@ describe('Resource options parser tests', () => {
 
     expect(() => new ParsedResourceSettings(option)).toThrowError()
   })
+
+  it('Can handle a zod schema', () => {
+
+    const schema = z.object({
+      propA: z.string(),
+      repository: z.string(),
+    })
+
+    const option: ResourceSettings<z.infer<typeof schema>> = {
+      id: 'typeId',
+      operatingSystems: [OS.Darwin],
+      schema,
+      importAndDestroy: {
+        defaultRefreshValues: {
+          repository: 'abc'
+        }
+      }
+    }
+
+    console.log(new ParsedResourceSettings(option))
+
+  })
 })

package/src/resource/parsed-resource-settings.ts

@@ -1,5 +1,6 @@
 import { JSONSchemaType } from 'ajv';
-import { OS, StringIndexedObject } from 'codify-schemas';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
+import { ZodObject, z } from 'zod';
 
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import {
@@ -7,12 +8,12 @@ import {
   DefaultParameterSetting,
   InputTransformation,
   ParameterSetting,
+  ResourceSettings,
+  StatefulParameterSetting,
   resolveElementEqualsFn,
   resolveEqualsFn,
   resolveMatcher,
-  resolveParameterTransformFn,
-  ResourceSettings,
-  StatefulParameterSetting
+  resolveParameterTransformFn
 } from './resource-settings.js';
 
 export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
@@ -29,7 +30,7 @@ export type ParsedArrayParameterSetting = {
 
 export type ParsedParameterSetting =
   {
-  isEqual: (desired: unknown, current: unknown) => boolean;
+    isEqual: (desired: unknown, current: unknown) => boolean;
   } & (DefaultParameterSetting
   | ParsedArrayParameterSetting
   | ParsedStatefulParameterSetting)
@@ -37,10 +38,13 @@ export type ParsedParameterSetting =
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
   private cache = new Map<string, unknown>();
   id!: string;
+  description?: string;
+
   schema?: Partial<JSONSchemaType<T | any>>;
   allowMultiple?: {
+    identifyingParameters?: string[];
     matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
-    requiredParameters?: string[]
+    findAllParameters?: () => Promise<Array<Partial<T>>>
   } | boolean;
 
   removeStatefulParametersBeforeDestroy?: boolean | undefined;
@@ -48,16 +52,30 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
   transformation?: InputTransformation;
 
   operatingSystems!: Array<OS>;
+  linuxDistros?: Array<LinuxDistro>;
+
   isSensitive?: boolean;
 
   private settings: ResourceSettings<T>;
 
   constructor(settings: ResourceSettings<T>) {
     this.settings = settings;
+    const { parameterSettings, schema, ...rest } = settings;
 
-    const { parameterSettings, ...rest } = settings;
     Object.assign(this, rest);
 
+    if (schema) {
+      this.schema = schema instanceof ZodObject
+        ? z.toJSONSchema(schema.strict(), {
+          target: 'draft-7',
+          override(ctx) {
+            ctx.jsonSchema.title = settings.id;
+            ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+          }
+        }) as JSONSchemaType<T>
+        : schema;
+    }
+
     this.validateSettings();
   }
 
@@ -199,7 +217,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`)
     }
 
-    const schema = this.settings.schema as JSONSchemaType<any>;
+    const schema = this.schema as JSONSchemaType<any>;
     if (!this.settings.importAndDestroy && (schema?.oneOf
         && Array.isArray(schema.oneOf)
         && schema.oneOf.some((s) => s.required)

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

@@ -11,6 +11,7 @@ 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';
+import { z } from 'zod';
 
 describe('Resource tests', () => {
 
@@ -952,4 +953,129 @@ describe('Resource tests', () => {
 
     process.env = oldProcessEnv;
   })
+
+  it('Can import and return all of the imported parameters (zod schema)', async () => {
+    const schema = z.object({
+      path: z
+        .string()
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      paths: z
+        .array(z.string())
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      prepend: z
+        .boolean()
+        .describe(
+          'Whether to prepend the paths to the PATH environment variable'
+        ),
+      declarationsOnly: z
+        .boolean()
+        .describe(
+          'Whether to only declare the paths in the PATH environment variable'
+        ),
+    })
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          schema,
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'directory' },
+            paths: { canModify: true, type: 'array', itemType: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshMapper: (input, context) => {
+              if (Object.keys(input).length === 0) {
+                return { paths: [], declarationsOnly: true };
+              }
+
+              return input;
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          paths: [
+            `${os.homedir()}/.pyenv/bin`,
+            `${os.homedir()}/.bun/bin`,
+            `${os.homedir()}/.deno/bin`,
+            `${os.homedir()}/.jenv/bin`,
+            `${os.homedir()}/a/random/path`,
+            `${os.homedir()}/.nvm/.bin/2`,
+            `${os.homedir()}/.nvm/.bin/3`
+          ]
+        }
+      }
+    }
+
+    const oldProcessEnv = structuredClone(process.env);
+
+    process.env['PYENV_ROOT'] = `${os.homedir()}/.pyenv`
+    process.env['BUN_INSTALL'] = `${os.homedir()}/.bun`
+    process.env['DENO_INSTALL'] = `${os.homedir()}/.deno`
+    process.env['JENV'] = `${os.homedir()}/.jenv`
+    process.env['NVM_DIR'] = `${os.homedir()}/.nvm`
+
+    const controller = new ResourceController(resource);
+    const importResult1 = await controller.import({ type: 'path' }, {});
+    expect(importResult1).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    const importResult2 = await controller.import({ type: 'path' }, { paths: ['$PYENV_ROOT/bin', '$BUN_INSTALL/bin'] });
+    expect(importResult2).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    process.env = oldProcessEnv;
+  })
 });

package/src/resource/resource-controller.ts

@@ -36,18 +36,17 @@ export class ResourceController<T extends StringIndexedObject> {
 
     this.typeId = this.settings.id;
     this.dependencies = this.settings.dependencies ?? [];
+    this.parsedSettings = new ParsedResourceSettings<T>(this.settings);
 
-    if (this.settings.schema) {
+    if (this.parsedSettings.schema) {
       this.ajv = new Ajv({
         allErrors: true,
         strict: true,
         strictRequired: false,
         allowUnionTypes: true
       })
-      this.schemaValidator = this.ajv.compile(this.settings.schema);
+      this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
     }
-
-    this.parsedSettings = new ParsedResourceSettings<T>(this.settings);
   }
 
   async initialize(): Promise<void> {
@@ -526,8 +525,8 @@ ${JSON.stringify(refresh, null, 2)}
   }
 
   private getAllParameterKeys(): string[] {
-    return this.settings.schema
-      ? Object.keys((this.settings.schema as any)?.properties)
+    return this.parsedSettings.schema
+      ? Object.keys((this.parsedSettings.schema as any)?.properties)
       : Object.keys(this.parsedSettings.parameterSettings);
   }
 

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

@@ -13,6 +13,7 @@ import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './res
 import { ResourceController } from './resource-controller.js';
 import os from 'node:os';
 import path from 'node:path';
+import { z } from 'zod';
 
 describe('Resource parameter tests', () => {
   it('Generates a resource plan that includes stateful parameters (create)', async () => {
@@ -1174,4 +1175,39 @@ describe('Resource parameter tests', () => {
     expect(from2).to.eq('$HOME/abc/def')
 
   })
+
+  it('Can match directories 2', async () => {
+
+    const schema = z.object({
+      propA: z.string(),
+      propB: z.number(),
+    });
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<z.infer<typeof schema>> {
+        return {
+          id: 'resourceType',
+          schema,
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { type: 'directory' }
+          },
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+    const transformations = controller.parsedSettings.inputTransformations.propA;
+
+    const to = transformations!.to('$HOME/abc/def')
+    expect(to).to.eq(os.homedir() + '/abc/def')
+
+    const from = transformations!.from(os.homedir() + '/abc/def')
+    expect(from).to.eq('~/abc/def')
+
+    const from2 = transformations!.from(os.homedir() + '/abc/def', '$HOME/abc/def')
+    expect(from2).to.eq('$HOME/abc/def')
+
+  })
+
 })

package/src/resource/resource-settings.ts

@@ -1,7 +1,8 @@
 import { JSONSchemaType } from 'ajv';
-import { OS, StringIndexedObject } from 'codify-schemas';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
 import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
+import { ZodObject } from 'zod';
 
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import {
@@ -11,6 +12,7 @@ import {
   tildify,
   untildify
 } from '../utils/functions.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { RefreshContext } from './resource.js';
 
 export interface InputTransformation {
@@ -33,10 +35,15 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   operatingSystems: Array<OS>;
 
+  /**
+   * List of supported linux distros
+   */
+  linuxDistros?: Array<LinuxDistro>;
+
   /**
    * Schema to validate user configs with. Must be in the format JSON Schema draft07
    */
-  schema?: Partial<JSONSchemaType<T | any>>;
+  schema?: Partial<JSONSchemaType<T | any>> | ZodObject;
 
   /**
    * Mark the resource as sensitive. Defaults to false. This prevents the resource from automatically being imported by init and import.
@@ -44,6 +51,11 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   isSensitive?: boolean;
 
+  /**
+   * An optional description of the resource. This does not affect the behavior of the resource.
+   */
+  description?: string;
+
   /**
    * Allow multiple of the same resource to unique. Set truthy if
    * multiples are allowed, for example for applications, there can be multiple copy of the same application installed
@@ -349,7 +361,7 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
 
 const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
   'boolean': (a: unknown, b: unknown) => Boolean(a) === Boolean(b),
-  'directory': (a: unknown, b: unknown) => {
+  'directory'(a: unknown, b: unknown) {
     let transformedA = resolvePathWithVariables(untildify(String(a)))
     let transformedB = resolvePathWithVariables(untildify(String(b)))
 
@@ -430,7 +442,7 @@ export function resolveFnFromEqualsFnOrString(
 const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, InputTransformation>> = {
   'directory': {
     to: (a: unknown) => resolvePathWithVariables((untildify(String(a)))),
-    from: (a: unknown, original) => {
+    from(a: unknown, original) {
       if (ParameterEqualsDefaults.directory!(a, original)) {
         return original;
       }
@@ -489,7 +501,7 @@ export function resolveParameterTransformFn(
 }
 
 export function resolveMatcher<T extends StringIndexedObject>(
-  settings: ResourceSettings<T>
+  settings: ParsedResourceSettings<T>
 ): (desired: Partial<T>, current: Partial<T>) => boolean {
   return typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple?.matcher
     ? ((desired: Partial<T>, current: Partial<T>) => {

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'));
+  })
+})