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

package/bin/build.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { Ajv } from 'ajv';
+import { IpcMessageSchema, MessageStatus, ResourceSchema } from 'codify-schemas';
+import mergeJsonSchemas from 'merge-json-schemas';
+import { fork } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { SequentialPty, VerbosityLevel } from '../dist/index.js';
+
+const ajv = new Ajv({
+  strict: true
+});
+const ipcMessageValidator = ajv.compile(IpcMessageSchema);
+
+function sendMessageAndAwaitResponse(process, message) {
+  return new Promise((resolve, reject) => {
+    process.on('message', (response) => {
+      if (!ipcMessageValidator(response)) {
+        throw new Error(`Invalid message from plugin. ${JSON.stringify(message, null, 2)}`);
+      }
+
+      // Wait for the message response. Other messages such as sudoRequest may be sent before the response returns
+      if (response.cmd === message.cmd + '_Response') {
+        if (response.status === MessageStatus.SUCCESS) {
+          resolve(response.data)
+        } else {
+          reject(new Error(String(response.data)))
+        }
+      }
+    });
+
+    // Send message last to ensure listeners are all registered
+    process.send(message);
+  });
+}
+
+function fetchDocumentationMaps() {
+  console.log('Building documentation...');
+
+  const results = new Map();
+  const resourcesPath = path.resolve(process.cwd(), 'src', 'resources');
+  const resourcesDir = fs.readdirSync(resourcesPath);
+
+  for (const resource of resourcesDir) {
+    const resourcePath = path.join(resourcesPath, resource);
+    if (!isDirectory(resourcePath)) continue;
+
+    const contents = fs.readdirSync(resourcePath);
+    const isGroup = contents.some((content) => isDirectory(path.join(resourcePath, content)));
+    const isAllDir = contents.every((content) => isDirectory(path.join(resourcePath, content)));
+
+    if (isGroup && !isAllDir) {
+      throw new Error(`Documentation groups must only contain directories. ${resourcePath} does not`);
+    }
+
+    if (!isGroup) {
+      if (contents.includes('README.md')) {
+        results.set(resource, resource);
+      }
+    } else {
+      for (const innerDir of contents) {
+        const innerDirReadme = path.join(resourcePath, innerDir, 'README.md');
+        if (isFile(innerDirReadme)) {
+          results.set(innerDir, path.relative('./src/resources', path.join(resourcePath, innerDir)));
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+function isDirectory(path) {
+  try {
+    return fs.statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function isFile(path) {
+  try {
+    return fs.statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+VerbosityLevel.set(3);
+const $ = new SequentialPty();
+
+await $.spawn('rm -rf ./dist')
+await $.spawn('npm run rollup -- -f es', { interactive: true });
+
+const plugin = fork(
+  './dist/index.js',
+  [],
+  {
+    // Use default true to test plugins in secure mode (un-able to request sudo directly)
+    detached: true,
+    env: { ...process.env },
+    execArgv: ['--import', 'tsx/esm'],
+  },
+)
+
+const initializeResult = await sendMessageAndAwaitResponse(plugin, {
+  cmd: 'initialize',
+  data: {}
+})
+
+const { resourceDefinitions } = initializeResult;
+const resourceTypes = resourceDefinitions.map((i) => i.type);
+const resourceInfoMap = new Map();
+
+const schemasMap = new Map()
+for (const type of resourceTypes) {
+  const resourceInfo = await sendMessageAndAwaitResponse(plugin, {
+    cmd: 'getResourceInfo',
+    data: { type }
+  })
+
+  schemasMap.set(type, resourceInfo.schema);
+  resourceInfoMap.set(type, resourceInfo);
+}
+
+console.log(resourceInfoMap);
+
+const mergedSchemas = [...schemasMap.entries()].map(([type, schema]) => {
+  // const resolvedSchema = await $RefParser.dereference(schema)
+  const resourceSchema = JSON.parse(JSON.stringify(ResourceSchema));
+
+  delete resourceSchema.$id;
+  delete resourceSchema.$schema;
+  delete resourceSchema.title;
+  delete resourceSchema.oneOf;
+  delete resourceSchema.properties.type;
+
+  if (schema) {
+    delete schema.$id;
+    delete schema.$schema;
+    delete schema.title;
+    delete schema.oneOf;
+  }
+
+  return mergeJsonSchemas([schema ?? {}, resourceSchema, { properties: { type: { const: type, type: 'string' } } }]);
+});
+
+
+await $.spawn('rm -rf ./dist')
+await $.spawn('npm run rollup', { interactive: true }); // re-run rollup without building for es
+
+console.log('Generated JSON Schemas for all resources')
+
+const distFolder = path.resolve(process.cwd(), 'dist');
+const schemaOutputPath = path.resolve(distFolder, 'schemas.json');
+fs.writeFileSync(schemaOutputPath, JSON.stringify(mergedSchemas, null, 2));
+
+console.log('Successfully wrote schema to ./dist/schemas.json');
+
+const documentationMap = fetchDocumentationMaps();
+
+const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+
+fs.writeFileSync('./dist/manifest.json', JSON.stringify({
+  name: packageJson.name,
+  version: packageJson.version,
+  description: packageJson.description,
+  resources: [...resourceInfoMap.values()].map((info) => ({
+    type: info.type,
+    description: info.description ?? info.schema?.description,
+    sensitiveParameters: info.sensitiveParameters,
+    schema: info.schema,
+    operatingSystems: info.operatingSystems,
+    documentationKey: documentationMap.get(info.type),
+  })),
+}, null, 2), 'utf8');
+
+for (const key of documentationMap.values()) {
+  fs.mkdirSync(path.join('dist', 'documentation', key), { recursive: true })
+
+  fs.copyFileSync(
+    path.resolve(path.join('src', 'resources', key, 'README.md')),
+    path.resolve(path.join('dist', 'documentation', key, 'README.md')),
+  );
+}
+
+plugin.kill(9);
+process.exit(0);

package/dist/index.d.ts

@@ -5,7 +5,9 @@ export * from './plan/change-set.js';
 export * from './plan/plan.js';
 export * from './plan/plan-types.js';
 export * from './plugin/plugin.js';
+export * from './pty/background-pty.js';
 export * from './pty/index.js';
+export * from './pty/seqeuntial-pty.js';
 export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js';
 export * from './resource/resource-settings.js';
@@ -14,4 +16,5 @@ export * from './utils/file-utils.js';
 export * from './utils/functions.js';
 export * from './utils/index.js';
 export * from './utils/verbosity-level.js';
+export * from 'zod/v4';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -5,7 +5,9 @@ export * from './plan/change-set.js';
 export * from './plan/plan.js';
 export * from './plan/plan-types.js';
 export * from './plugin/plugin.js';
+export * from './pty/background-pty.js';
 export * from './pty/index.js';
+export * from './pty/seqeuntial-pty.js';
 export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js';
 export * from './resource/resource-settings.js';
@@ -14,6 +16,7 @@ export * from './utils/file-utils.js';
 export * from './utils/functions.js';
 export * from './utils/index.js';
 export * from './utils/verbosity-level.js';
+export * from 'zod/v4';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));

package/dist/messages/handlers.js

@@ -1,6 +1,6 @@
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
-import { ApplyRequestDataSchema, ApplyResponseDataSchema, GetResourceInfoRequestDataSchema, GetResourceInfoResponseDataSchema, ImportRequestDataSchema, ImportResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, IpcMessageV2Schema, MatchRequestDataSchema, MatchResponseDataSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
+import { ApplyRequestDataSchema, EmptyResponseDataSchema, GetResourceInfoRequestDataSchema, GetResourceInfoResponseDataSchema, ImportRequestDataSchema, ImportResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, IpcMessageV2Schema, MatchRequestDataSchema, MatchResponseDataSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, SetVerbosityRequestDataSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
 import { SudoError } from '../errors.js';
 const SupportedRequests = {
     'initialize': {
@@ -18,6 +18,14 @@ const SupportedRequests = {
         requestValidator: GetResourceInfoRequestDataSchema,
         responseValidator: GetResourceInfoResponseDataSchema
     },
+    'setVerbosityLevel': {
+        async handler(plugin, data) {
+            await plugin.setVerbosityLevel(data);
+            return null;
+        },
+        requestValidator: SetVerbosityRequestDataSchema,
+        responseValidator: EmptyResponseDataSchema,
+    },
     'match': {
         handler: async (plugin, data) => plugin.match(data),
         requestValidator: MatchRequestDataSchema,
@@ -39,7 +47,7 @@ const SupportedRequests = {
             return null;
         },
         requestValidator: ApplyRequestDataSchema,
-        responseValidator: ApplyResponseDataSchema
+        responseValidator: EmptyResponseDataSchema
     },
 };
 export class MessageHandler {

package/dist/plan/plan.js

@@ -187,6 +187,7 @@ export class Plan {
      *  or wants to set. If a parameter is not specified then it's not managed by Codify.
      */
     static filterCurrentParams(params) {
+        console.log('Filter current params', params.desired, params.current, params.state, params.settings, params.isStateful);
         const { desired, current, state, settings, isStateful } = params;
         if (!current) {
             return null;
@@ -195,15 +196,26 @@ export class Plan {
         if (!filteredCurrent) {
             return null;
         }
+        console.log('Before exit', isStateful, desired);
         // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
         // requires additional filtering for stateful parameter arrays and objects.
-        if (isStateful) {
+        if (isStateful && desired) {
             return filteredCurrent;
         }
+        // We also want to filter parameters when in delete mode. We don't want to delete parameters that
+        // are not specified in the original config.
+        if (isStateful && !desired) {
+            const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
+                .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
+                .map(([k, v]) => [k, filterArrayParameterForDeletes(k, v)]));
+            return { ...filteredCurrent, ...arrayStatefulParameters };
+        }
+        console.log('Post exit', isStateful, desired);
         // TODO: Add object handling here in addition to arrays in the future
         const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
             .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
-            .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)]));
+            .map(([k, v]) => [k, filterArrayParameterForStatelessMode(k, v)]));
+        console.log('Result', { ...filteredCurrent, ...arrayStatefulParameters });
         return { ...filteredCurrent, ...arrayStatefulParameters };
         function filterCurrent() {
             if (!current) {
@@ -244,7 +256,8 @@ export class Plan {
                 && Array.isArray(v);
         }
         // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
-        function filterArrayStatefulParameter(k, v) {
+        function filterArrayParameterForStatelessMode(k, v) {
+            console.log('Attempting to filter (key, value)', k, v);
             const desiredArray = desired[k];
             const matcher = settings.parameterSettings[k].type === 'stateful'
                 ? settings.parameterSettings[k]
@@ -272,6 +285,35 @@ export class Plan {
                 ? filterParameter(desiredCopy, currentCopy)
                 : defaultFilterMethod(desiredCopy, currentCopy);
         }
+        function filterArrayParameterForDeletes(k, v) {
+            console.log('Attempting to filter (key, value)', k, v);
+            const stateArray = state[k];
+            const matcher = settings.parameterSettings[k].type === 'stateful'
+                ? settings.parameterSettings[k]
+                    .nestedSettings
+                    .isElementEqual
+                : settings.parameterSettings[k]
+                    .isElementEqual;
+            const stateCopy = [...stateArray];
+            const currentCopy = [...v];
+            const defaultFilterMethod = ((state, current) => {
+                const result = [];
+                for (let counter = state.length - 1; counter >= 0; counter--) {
+                    const idx = currentCopy.findIndex((e2) => matcher(state[counter], e2));
+                    if (idx === -1) {
+                        continue;
+                    }
+                    state.splice(counter, 1);
+                    const [element] = current.splice(idx, 1);
+                    result.push(element);
+                }
+                return result;
+            });
+            const filterParameter = getFilterParameter(k);
+            return typeof filterParameter === 'function'
+                ? filterParameter(stateCopy, currentCopy)
+                : defaultFilterMethod(stateCopy, currentCopy);
+        }
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.
     //   1. For all scenarios, there shouldn't be an apply without a plan beforehand

package/dist/plugin/plugin.d.ts

@@ -1,4 +1,4 @@
-import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeRequestData, InitializeResponseData, MatchRequestData, MatchResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeRequestData, InitializeResponseData, MatchRequestData, MatchResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, SetVerbosityRequestData, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
 import { Resource } from '../resource/resource.js';
@@ -17,6 +17,7 @@ export declare class Plugin {
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;
     plan(data: PlanRequestData): Promise<PlanResponseData>;
     apply(data: ApplyRequestData): Promise<void>;
+    setVerbosityLevel(data: SetVerbosityRequestData): Promise<void>;
     kill(): Promise<void>;
     private resolvePlan;
     protected crossValidateResources(resources: ResourceJson[]): Promise<void>;

package/dist/plugin/plugin.js

@@ -46,6 +46,7 @@ export class Plugin {
                     type: r.typeId,
                     sensitiveParameters,
                     operatingSystems: r.settings.operatingSystems,
+                    linuxDistros: r.settings.linuxDistros,
                 };
             })
         };
@@ -55,7 +56,7 @@ export class Plugin {
             throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
         }
         const resource = this.resourceControllers.get(data.type);
-        const schema = resource.settings.schema;
+        const schema = resource.parsedSettings.schema;
         const requiredPropertyNames = (resource.settings.importAndDestroy?.requiredParameters
             ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)
             ?? schema?.required
@@ -84,6 +85,7 @@ export class Plugin {
                 requiredParameters: requiredPropertyNames,
             },
             operatingSystems: resource.settings.operatingSystems,
+            linuxDistros: resource.settings.linuxDistros,
             sensitiveParameters,
             allowMultiple
         };
@@ -173,6 +175,9 @@ export class Plugin {
             throw new ApplyValidationError(plan);
         }
     }
+    async setVerbosityLevel(data) {
+        VerbosityLevel.set(data.verbosityLevel);
+    }
     async kill() {
         await this.planPty.kill();
     }

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

@@ -6,11 +6,12 @@ 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();
-    spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
-    spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
     kill(): Promise<{
         exitCode: number;
         signal?: number | undefined;

package/dist/pty/background-pty.js

@@ -17,8 +17,11 @@ 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 },
+        cols: 10_000, // Set to a really large value to prevent wrapping
+        name: nanoid(6),
         handleFlowControl: true
     });
     promiseQueue = new PromiseQueue();
@@ -28,11 +31,12 @@ export class BackgroundPty {
     async spawn(cmd, options) {
         const spawnResult = await this.spawnSafe(cmd, options);
         if (spawnResult.status !== 'success') {
-            throw new SpawnError(cmd, spawnResult.exitCode, spawnResult.data);
+            throw new SpawnError(Array.isArray(cmd) ? cmd.join(' ') : cmd, spawnResult.exitCode, spawnResult.data);
         }
         return spawnResult;
     }
     async spawnSafe(cmd, options) {
+        cmd = Array.isArray(cmd) ? cmd.join('\\\n') : cmd;
         // cid is command id
         const cid = nanoid(10);
         debugLog(cid);
@@ -84,7 +88,7 @@ export class BackgroundPty {
                         resolve(null);
                     }
                 });
-                console.log(`Running command ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
+                console.log(`Running command: ${cmd}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
                 this.basePty.write(`${command}\r`);
             }));
         }).finally(async () => {
@@ -104,17 +108,6 @@ export class BackgroundPty {
         await this.promiseQueue.run(async () => {
             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;
-                    }
-                }
                 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

@@ -21,11 +21,17 @@ export declare enum SpawnStatus {
  *
  * @property {boolean} [interactive] - Indicates whether the spawned process needs
  * to be interactive. Only works within apply (not plan). Defaults to true.
+ *
+ * @property {boolean} [disableWrapping] - Forces the terminal width to 10_000 to disable wrapping.
+ * In applys, this is off by default while it is on during plans.
  */
 export interface SpawnOptions {
     cwd?: string;
     env?: Record<string, unknown>;
     interactive?: boolean;
+    requiresRoot?: boolean;
+    stdin?: boolean;
+    disableWrapping?: boolean;
 }
 export declare class SpawnError extends Error {
     data: string;
@@ -34,8 +40,8 @@ export declare class SpawnError extends Error {
     constructor(cmd: string, exitCode: number, data: string);
 }
 export interface IPty {
-    spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
-    spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
     kill(): Promise<{
         exitCode: number;
         signal?: number | undefined;

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

@@ -6,11 +6,12 @@ import { IPty, SpawnOptions, SpawnResult } from './index.js';
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export declare class SequentialPty implements IPty {
-    spawn(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
-    spawnSafe(cmd: string, options?: SpawnOptions): Promise<SpawnResult>;
+    spawn(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
+    spawnSafe(cmd: string | string[], options?: SpawnOptions): Promise<SpawnResult>;
     kill(): Promise<{
         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/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
@@ -15,12 +22,20 @@ export class SequentialPty {
     async spawn(cmd, options) {
         const spawnResult = await this.spawnSafe(cmd, options);
         if (spawnResult.status !== 'success') {
-            throw new SpawnError(cmd, spawnResult.exitCode, spawnResult.data);
+            throw new SpawnError(Array.isArray(cmd) ? cmd.join('\n') : cmd, spawnResult.exitCode, spawnResult.data);
         }
         return spawnResult;
     }
     async spawnSafe(cmd, options) {
-        console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
+        cmd = Array.isArray(cmd) ? cmd.join(' ') : cmd;
+        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: ${Array.isArray(cmd) ? cmd.join('\\\n') : cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
         return new Promise((resolve) => {
             const output = [];
             const historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
@@ -30,12 +45,14 @@ 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;
+            // Set to a really large value to prevent wrapping
+            const initialCols = options?.disableWrapping ? 10_000 : process.stdout.columns ?? 80;
             const initialRows = process.stdout.rows ?? 24;
-            const args = (options?.interactive ?? false) ? ['-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 +66,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);
+                mPty.resize(columns, options?.disableWrapping ? 10_000 : 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 +89,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/parsed-resource-settings.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { OS, StringIndexedObject } from 'codify-schemas';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { ArrayParameterSetting, DefaultParameterSetting, InputTransformation, ResourceSettings } from './resource-settings.js';
 export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
@@ -18,15 +18,18 @@ export type ParsedParameterSetting = {
 export declare class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
     private cache;
     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;
     dependencies?: string[] | undefined;
     transformation?: InputTransformation;
     operatingSystems: Array<OS>;
+    linuxDistros?: Array<LinuxDistro>;
     isSensitive?: boolean;
     private settings;
     constructor(settings: ResourceSettings<T>);