codify-plugin-lib 1.0.180 → 1.0.182-beta1

package/dist/bin/build.d.ts

@@ -0,0 +1 @@
+export declare function build(): Promise<void>;

package/dist/bin/build.js

@@ -0,0 +1,80 @@
+import { Ajv } from 'ajv';
+import { IpcMessageSchema, MessageStatus, ResourceSchema } from 'codify-schemas';
+// @ts-ignore
+import mergeJsonSchemas from 'merge-json-schemas';
+import { fork } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as url from 'node:url';
+import { codifySpawn } from '../utils/codify-spawn.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);
+    });
+}
+export async function build() {
+    await fs.rm('./dist', { force: true, recursive: true });
+    await codifySpawn('npm run rollup -- -f es');
+    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 schemasMap = new Map();
+    for (const type of resourceTypes) {
+        const resourceInfo = await sendMessageAndAwaitResponse(plugin, {
+            cmd: 'getResourceInfo',
+            data: { type }
+        });
+        schemasMap.set(type, resourceInfo.schema);
+    }
+    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 fs.rm('./dist', { force: true, recursive: true });
+    await codifySpawn('npm run rollup'); // re-run rollup without building for es
+    console.log('Generated JSON Schemas for all resources');
+    const distFolder = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), '..', 'dist');
+    const schemaOutputPath = path.resolve(distFolder, 'schemas.json');
+    await fs.writeFile(schemaOutputPath, JSON.stringify(mergedSchemas, null, 2));
+    console.log('Successfully wrote schema to ./dist/schemas.json');
+}

package/dist/bin/deploy-plugin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/deploy-plugin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import * as fs from 'node:fs';
+import { build } from './build.js';
+const packageJson = fs.readFileSync(path.join(process.env['npm_config_local_prefix'], 'package.json'), 'utf8');
+const { name: libraryName, version: libraryVersion } = JSON.parse(packageJson);
+console.log(libraryName, libraryVersion);
+await build();

package/dist/index.d.ts

@@ -10,5 +10,5 @@ export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js';
 export * from './resource/resource-settings.js';
 export * from './stateful-parameter/stateful-parameter.js';
-export * from './utils/utils.js';
+export * from './utils/index.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -10,7 +10,7 @@ export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js';
 export * from './resource/resource-settings.js';
 export * from './stateful-parameter/stateful-parameter.js';
-export * from './utils/utils.js';
+export * from './utils/index.js';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));

package/dist/plugin/plugin.js

@@ -2,9 +2,10 @@ import { ApplyValidationError } from '../common/errors.js';
 import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
 import { getPty } from '../pty/index.js';
+import { SequentialPty } from '../pty/seqeuntial-pty.js';
 import { ResourceController } from '../resource/resource-controller.js';
+import { VerbosityLevel } from '../utils/internal-utils.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
-import { VerbosityLevel } from '../utils/utils.js';
 export class Plugin {
     name;
     resourceControllers;
@@ -44,6 +45,7 @@ export class Plugin {
                     dependencies: r.dependencies,
                     type: r.typeId,
                     sensitiveParameters,
+                    operatingSystems: r.settings.operatingSystems,
                 };
             })
         };
@@ -81,6 +83,7 @@ export class Plugin {
             import: {
                 requiredParameters: requiredPropertyNames,
             },
+            operatingSystems: resource.settings.operatingSystems,
             sensitiveParameters,
             allowMultiple
         };
@@ -158,7 +161,7 @@ export class Plugin {
         if (!resource) {
             throw new Error('Malformed plan with resource that cannot be found');
         }
-        await resource.apply(plan);
+        await ptyLocalStorage.run(new SequentialPty(), async () => resource.apply(plan));
         // Validate using desired/desired. If the apply was successful, no changes should be reported back.
         // Default back desired back to current if it is not defined (for destroys only)
         const validationPlan = await ptyLocalStorage.run(new BackgroundPty(), async () => {

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

@@ -16,4 +16,5 @@ export declare class BackgroundPty implements IPty {
         signal?: number | undefined;
     }>;
     private initialize;
+    private getDefaultShell;
 }

package/dist/pty/background-pty.js

@@ -5,7 +5,8 @@ import { EventEmitter } from 'node:events';
 import * as fs from 'node:fs/promises';
 import stripAnsi from 'strip-ansi';
 import { debugLog } from '../utils/debug.js';
-import { VerbosityLevel } from '../utils/utils.js';
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/internal-utils.js';
 import { SpawnError } from './index.js';
 import { PromiseQueue } from './promise-queue.js';
 EventEmitter.defaultMaxListeners = 1000;
@@ -16,7 +17,7 @@ EventEmitter.defaultMaxListeners = 1000;
  * without a tty (or even a stdin) attached so interactive commands will not work.
  */
 export class BackgroundPty {
-    basePty = pty.spawn('zsh', ['-i'], {
+    basePty = pty.spawn(this.getDefaultShell(), ['-i'], {
         env: process.env, name: nanoid(6),
         handleFlowControl: true
     });
@@ -103,7 +104,17 @@ export class BackgroundPty {
         await this.promiseQueue.run(async () => {
             let outputBuffer = '';
             return new Promise(resolve => {
-                this.basePty.write('setopt hist_ignore_space;\n');
+                // 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');
@@ -117,4 +128,7 @@ export class BackgroundPty {
             });
         });
     }
+    getDefaultShell() {
+        return process.env.SHELL;
+    }
 }

package/dist/pty/index.d.ts

@@ -1,5 +1,5 @@
 export interface SpawnResult {
-    status: 'success' | 'error';
+    status: 'error' | 'success';
     exitCode: number;
     data: string;
 }
@@ -7,9 +7,25 @@ export declare enum SpawnStatus {
     SUCCESS = "success",
     ERROR = "error"
 }
+/**
+ * Represents the configuration options for spawning a child process.
+ *
+ * @interface SpawnOptions
+ *
+ * @property {string} [cwd] - Specifies the working directory of the child process.
+ * If not provided, the current working directory of the parent process is used.
+ *
+ * @property {Record<string, unknown>} [env] - Defines environment key-value pairs
+ * that will be available to the child process. If not specified, the child process
+ * will inherit the environment variables of the parent process.
+ *
+ * @property {boolean} [interactive] - Indicates whether the spawned process needs
+ * to be interactive. Only works within apply (not plan). Defaults to true.
+ */
 export interface SpawnOptions {
     cwd?: string;
     env?: Record<string, unknown>;
+    interactive?: boolean;
 }
 export declare class SpawnError extends Error {
     data: string;

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

@@ -0,0 +1,16 @@
+import { IPty, SpawnOptions, SpawnResult } from './index.js';
+/**
+ * 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
+ * to listen to stdout and stderr. One limitation of the BackgroundPty is that the tasks run
+ * 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>;
+    kill(): Promise<{
+        exitCode: number;
+        signal?: number | undefined;
+    }>;
+    private getDefaultShell;
+}

package/dist/pty/seqeuntial-pty.js

@@ -0,0 +1,84 @@
+import pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { EventEmitter } from 'node:events';
+import stripAnsi from 'strip-ansi';
+import { Shell, Utils } from '../utils/index.js';
+import { VerbosityLevel } from '../utils/internal-utils.js';
+import { SpawnError, SpawnStatus } from './index.js';
+EventEmitter.defaultMaxListeners = 1000;
+/**
+ * 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
+ * to listen to stdout and stderr. One limitation of the BackgroundPty is that the tasks run
+ * without a tty (or even a stdin) attached so interactive commands will not work.
+ */
+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);
+        }
+        return spawnResult;
+    }
+    async spawnSafe(cmd, options) {
+        console.log(`Running command: ${cmd}` + (options?.cwd ? `(${options?.cwd})` : ''));
+        return new Promise((resolve) => {
+            const output = [];
+            const historyIgnore = Utils.getShell() === Shell.ZSH ? { HISTORY_IGNORE: '*' } : { HISTIGNORE: '*' };
+            // If TERM_PROGRAM=Apple_Terminal is set then ANSI escape characters may be included
+            // in the response.
+            const env = {
+                ...process.env, ...options?.env,
+                TERM_PROGRAM: 'codify',
+                COMMAND_MODE: 'unix2003',
+                COLORTERM: 'truecolor', ...historyIgnore
+            };
+            // Initial terminal dimensions
+            const initialCols = process.stdout.columns ?? 80;
+            const initialRows = process.stdout.rows ?? 24;
+            const args = (options?.interactive ?? true) ? ['-i', '-c', `"${cmd}"`] : ['-c', `"${cmd}"`];
+            // Run the command in a pty for interactivity
+            const mPty = pty.spawn(this.getDefaultShell(), args, {
+                ...options,
+                cols: initialCols,
+                rows: initialRows,
+                env
+            });
+            mPty.onData((data) => {
+                if (VerbosityLevel.get() > 0) {
+                    process.stdout.write(data);
+                }
+                output.push(data.toString());
+            });
+            const stdinListener = (data) => {
+                mPty.write(data.toString());
+            };
+            const resizeListener = () => {
+                const { columns, rows } = process.stdout;
+                mPty.resize(columns, rows);
+            };
+            // Listen to resize events for the terminal window;
+            process.stdout.on('resize', resizeListener);
+            // Listen for user input
+            process.stdin.on('data', stdinListener);
+            mPty.onExit((result) => {
+                process.stdout.off('resize', resizeListener);
+                process.stdin.off('data', stdinListener);
+                resolve({
+                    status: result.exitCode === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                    exitCode: result.exitCode,
+                    data: stripAnsi(output.join('\n').trim()),
+                });
+            });
+        });
+    }
+    async kill() {
+        // No-op here. Each pty instance is stand alone and tied to the parent process. Everything should be killed as expected.
+        return {
+            exitCode: 0,
+            signal: 0,
+        };
+    }
+    getDefaultShell() {
+        return process.env.SHELL;
+    }
+}

package/dist/resource/parsed-resource-settings.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { StringIndexedObject } from 'codify-schemas';
+import { 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 {
@@ -26,6 +26,8 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
     dependencies?: string[] | undefined;
     transformation?: InputTransformation;
+    operatingSystems: Array<OS>;
+    isSensitive?: boolean;
     private settings;
     constructor(settings: ResourceSettings<T>);
     get typeId(): string;

package/dist/resource/parsed-resource-settings.js

@@ -8,15 +8,13 @@ export class ParsedResourceSettings {
     removeStatefulParametersBeforeDestroy;
     dependencies;
     transformation;
+    operatingSystems;
+    isSensitive;
     settings;
     constructor(settings) {
         this.settings = settings;
-        this.id = settings.id;
-        this.schema = settings.schema;
-        this.allowMultiple = settings.allowMultiple;
-        this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
-        this.dependencies = settings.dependencies;
-        this.transformation = settings.transformation;
+        const { parameterSettings, ...rest } = settings;
+        Object.assign(this, rest);
         this.validateSettings();
     }
     get typeId() {

package/dist/resource/resource-settings.d.ts

@@ -1,5 +1,5 @@
 import { JSONSchemaType } from 'ajv';
-import { StringIndexedObject } from 'codify-schemas';
+import { OS, StringIndexedObject } from 'codify-schemas';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { RefreshContext } from './resource.js';
 export interface InputTransformation {
@@ -14,6 +14,10 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * The typeId of the resource.
      */
     id: string;
+    /**
+     * List of supported operating systems
+     */
+    operatingSystems: Array<OS>;
     /**
      * Schema to validate user configs with. Must be in the format JSON Schema draft07
      */

package/dist/resource/resource-settings.js

@@ -1,6 +1,6 @@
 import isObjectsEqual from 'lodash.isequal';
 import path from 'node:path';
-import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/utils.js';
+import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/internal-utils.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => {
@@ -12,8 +12,9 @@ const ParameterEqualsDefaults = {
         if (transformedB.startsWith('.')) { // Only relative paths start with '.'
             transformedB = path.resolve(transformedB);
         }
-        const notCaseSensitive = process.platform === 'darwin';
-        if (notCaseSensitive) {
+        // macOS has case-insensitive filesystem by default, Linux is case-sensitive
+        const isCaseSensitive = process.platform === 'linux';
+        if (!isCaseSensitive) {
             transformedA = transformedA.toLowerCase();
             transformedB = transformedB.toLowerCase();
         }

package/dist/scripts/deploy.d.ts

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

package/dist/scripts/deploy.js

@@ -0,0 +1,2 @@
+console.log('Deploying!!');
+export {};

package/dist/utils/codify-spawn.d.ts

@@ -0,0 +1,29 @@
+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;
+    requestsTTY?: 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 codifySpawn(cmd: string, opts?: CodifySpawnOptions): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/codify-spawn.js

@@ -0,0 +1,136 @@
+import { Ajv } from 'ajv';
+import { MessageCmd, SudoRequestResponseDataSchema } from 'codify-schemas';
+import { nanoid } from 'nanoid';
+import { spawn } from 'node:child_process';
+import stripAnsi from 'strip-ansi';
+import { VerbosityLevel } from './utils.js';
+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 codifySpawn(cmd, opts) {
+    const throws = opts?.throws ?? true;
+    console.log(`Running command: ${cmd}` + (opts?.cwd ? `(${opts?.cwd})` : ''));
+    try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
+        const result = await (opts?.requiresRoot
+            ? externalSpawnWithSudo(cmd, opts)
+            : internalSpawn(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);
+        }
+        // @ts-ignore
+        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: String(error),
+        };
+    }
+}
+async function internalSpawn(cmd, opts) {
+    return new Promise((resolve) => {
+        const output = [];
+        // If TERM_PROGRAM=Apple_Terminal is set then ANSI escape characters may be included
+        // in the response.
+        const env = { ...process.env, ...opts.env, TERM_PROGRAM: 'codify', COMMAND_MODE: 'unix2003', COLORTERM: 'truecolor' };
+        const shell = getDefaultShell();
+        const rcFile = shell === 'zsh' ? '~/.zshrc' : '~/.bashrc';
+        // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+        // Ignore all stdin
+        // If tty is requested then we'll need to sleep 1 to avoid race conditions. This is because if the terminal updates async after the tty message is
+        // displayed then it'll disappear. By adding sleep 1 it'll allow ink.js to finish all the updates before the tty message is shown
+        const _process = spawn(`source ${rcFile}; ${opts.requestsTTY ? 'sleep 1;' : ''}${cmd}`, [], {
+            ...opts,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell,
+            env
+        });
+        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 && VerbosityLevel.get() > 0) {
+            stdout.pipe(process.stdout);
+            stderr.pipe(process.stderr);
+        }
+        _process.on('close', (code) => {
+            resolve({
+                status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                data: stripAnsi(output.join('\n')),
+            });
+        });
+    });
+}
+async function externalSpawnWithSudo(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.SUDO_REQUEST,
+            data: {
+                command: cmd,
+                options: opts ?? {},
+            },
+            requestId
+        });
+    });
+}
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}
+function getDefaultShell() {
+    return process.platform === 'darwin' ? 'zsh' : 'bash';
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,25 @@
+import { OS } from 'codify-schemas';
+export declare enum Shell {
+    ZSH = "zsh",
+    BASH = "bash",
+    SH = "sh",
+    KSH = "ksh",
+    CSH = "csh",
+    FISH = "fish"
+}
+export interface SystemInfo {
+    os: OS;
+    shell: Shell;
+}
+export declare const Utils: {
+    getUser(): string;
+    getSystemInfo(): {
+        os: string;
+        shell: Shell | undefined;
+    };
+    isMacOS(): boolean;
+    isLinux(): boolean;
+    getShell(): Shell | undefined;
+    getPrimaryShellRc(): string;
+    getShellRcFiles(): string[];
+};