hostctl 0.1.32

package/dist/index.d.ts

@@ -0,0 +1,1693 @@
+import { ParsedPath } from 'node:path';
+import { Signal } from 'human-signals';
+import { StringBuilder } from 'typescript-string-operations';
+import { Readable } from 'node:stream';
+import * as cmdr from 'commander';
+
+declare class Identity {
+    identityFilePath: string;
+    private identity;
+    constructor({ path, identity }: {
+        path?: string;
+        identity?: string;
+    });
+    get recipient(): Promise<string>;
+    private writeTmpIdentityFile;
+    private readIdentityFromFile;
+    get privateKey(): string;
+    get publicKey(): Promise<string>;
+    decrypt(encryptedString: string): Promise<string | null>;
+    encrypt(plaintext: string): Promise<string>;
+}
+
+type YamlHost = {
+    alias?: string;
+    user?: string;
+    password?: SecretRef | string;
+    'ssh-key'?: SecretRef | string;
+    tags?: string[];
+};
+type YamlHostsMapping = {
+    [key: string]: YamlHost;
+};
+type YamlSecret = {
+    ids: string | string[];
+    value: string;
+};
+type YamlSecretsMapping = {
+    [key: string]: YamlSecret;
+};
+type YamlIdsMapping = {
+    [key: string]: string | string[];
+};
+type YamlConfigFile = {
+    hosts?: YamlHostsMapping;
+    secrets?: YamlSecretsMapping;
+    ids?: YamlIdsMapping;
+};
+declare class SecretRef {
+    name: string;
+    constructor(name: string);
+    toYAML(): this;
+}
+declare class SecretValue {
+    private value;
+    constructor(value: string);
+    encrypt(recipients: string[]): Promise<string>;
+    decrypt(identities: Identity[]): Promise<string | undefined>;
+    isEncrypted(): boolean;
+    toYAML(): string;
+}
+declare class Secret implements ISecret {
+    config: ConfigFile;
+    name: string;
+    ids: RecipientGroup;
+    value: SecretValue;
+    constructor(config: ConfigFile, name: string, ids: RecipientGroup, value: SecretValue);
+    recipients(): string[];
+    ciphertext(): Promise<string>;
+    plaintext(): Promise<string | undefined>;
+    encrypt(): Promise<string>;
+    decrypt(): Promise<string | undefined>;
+    toYAML(): {
+        ids: string[];
+        value: string;
+    };
+}
+declare class RecipientGroup implements IRecipientGroup {
+    config: ConfigFile;
+    publicKeys: string[];
+    idRefs: string[];
+    constructor(config: ConfigFile, publicKeys: string[], idRefs: string[]);
+    recipients(): string[];
+    walkRecipientGroups(visitFn: (rg: RecipientGroup) => void, visited?: Set<RecipientGroup>): void;
+    toYAML(): string[];
+}
+declare class ConfigFile implements Config {
+    path: string;
+    _hosts: Map<string, Host>;
+    _ids: Map<string, RecipientGroup>;
+    _secrets: Map<string, Secret>;
+    constructor(path: string);
+    load(): Promise<void>;
+    parse(yamlDocument: YamlConfigFile): void;
+    parseSecretValue(yamlSecretValue: SecretRef | string | undefined): SecretRef | string | undefined;
+    parseHosts(yamlHosts: YamlHostsMapping): Map<string, Host>;
+    parseIdsMap(yamlIds: YamlIdsMapping): Map<string, RecipientGroup>;
+    parseRecipients(ids: string | string[] | (string | string[])[]): RecipientGroup;
+    isValidPublicKey(str: string): boolean;
+    parseSecrets(yamlSecrets: YamlSecretsMapping): Map<string, Secret>;
+    save(destinationPath?: string): Promise<void>;
+    serializeHosts(): any;
+    serializeSecrets(): any;
+    serializeIds(): any;
+    loadPrivateKeys(): Identity[];
+    getSecret(name: string): Secret | undefined;
+    getRecipientGroups(idRefs: string[]): RecipientGroup[];
+    decryptAllIfPossible(): Promise<void>;
+    encryptAll(): Promise<void>;
+    hosts(): Host[];
+    secrets(): Map<string, Secret>;
+    ids(): Map<string, RecipientGroup>;
+}
+
+declare class Host {
+    config: ConfigFile;
+    hostname: string;
+    alias?: string;
+    port: number;
+    user?: string;
+    password?: SecretRef | string;
+    sshKey?: SecretRef | string;
+    tags: string[];
+    tagSet: Set<string>;
+    constructor(config: ConfigFile, opts: {
+        hostname: string;
+        alias?: string;
+        port?: number;
+        user?: string;
+        password?: SecretRef | string;
+        sshKey?: SecretRef | string;
+        tags?: string[];
+    });
+    decryptedPassword(): Promise<string | undefined>;
+    decryptedSshKey(): Promise<string | undefined>;
+    toYAML(): {
+        alias: string | undefined;
+        user: string | undefined;
+        port: number | undefined;
+        password: string | SecretRef | undefined;
+        'ssh-key': string | SecretRef | undefined;
+        tags: string[];
+    };
+    get shortName(): string;
+    isLocal(): boolean;
+    get uri(): string;
+    writeTmpDecryptedSshKey(): Promise<string | undefined>;
+    private _plaintextSshKeyPath;
+    plaintextSshKeyPath(): Promise<string | undefined>;
+    toObject(): {
+        hostname: string;
+        port: number;
+        alias: string | undefined;
+        user: string | undefined;
+        tags: string[];
+    };
+    hasTag(tag: string): boolean;
+    hasAllTags(tags: Set<string>): boolean;
+    hasAnyTag(tags: Set<string>): boolean;
+}
+
+interface ISecret {
+    name: string;
+    recipients(): string[];
+    ciphertext(): Promise<string>;
+    plaintext(): Promise<string | undefined>;
+}
+interface IRecipientGroup {
+    recipients(): string[];
+}
+interface Config {
+    hosts(): Host[];
+    secrets(): Map<string, Secret>;
+    ids(): Map<string, RecipientGroup>;
+    getSecret(name: string): ISecret | undefined;
+    getRecipientGroups(idRefs: string[]): IRecipientGroup[];
+}
+
+declare class Path {
+    path: string;
+    isWindowsPath: boolean;
+    static new(path: Path | string, isWindowsPath?: boolean): Path;
+    static cwd(): Path;
+    static homeDir(): Path;
+    static sep(isWindowsPath?: boolean): "\\" | "/";
+    constructor(path: string, isWindowsPath?: boolean);
+    absolute(): Path;
+    ancestors(): Path[];
+    basename(suffix?: string): Path;
+    build(path: string): Path;
+    copy(destPath: Path | string, mode?: number): Promise<Path | null>;
+    dirContains(filename: string): boolean;
+    directory(): Path;
+    directorySegments(): string[];
+    dirname(): Path;
+    equals(other: any): boolean;
+    exists(): boolean;
+    ext(): string;
+    glob(pattern: string): Path[];
+    isAbsolute(): boolean;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isPosix(): boolean;
+    isRoot(): boolean;
+    isWindows(): boolean;
+    join(...paths: string[]): Path;
+    normalize(): Path;
+    parent(count?: number): Path;
+    parse(): ParsedPath;
+    pop(count?: number): Path;
+    relative(to: string): Path;
+    resolve(...paths: string[]): Path;
+    root(): Path;
+    selfAndAncestors(): Path[];
+    split(): string[];
+    toString(): string;
+}
+
+type EnvVarObj = Record<string, string>;
+declare class CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    signal?: Signal | undefined;
+    constructor(stdout: string, stderr: string, exitCode: number, signal?: Signal | undefined);
+    toJSON(): {
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        signal: Signal | undefined;
+        success: boolean;
+        failure: boolean;
+    };
+    get out(): string;
+    get err(): string;
+    get exit(): number;
+    get sig(): Signal | undefined;
+    get success(): boolean;
+    get failure(): boolean;
+}
+declare class Command {
+    static parse(commandString: string, env?: EnvVarObj): {
+        cmd: string;
+        args: string[];
+        env?: EnvVarObj;
+    };
+    cmd: string;
+    args?: string[] | undefined;
+    cwd?: string;
+    env?: Record<string, string>;
+    result?: CommandResult;
+    constructor(opts: {
+        cmd: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        result?: CommandResult;
+    });
+    isRunning(): boolean;
+    toJSON(): {
+        cmd: string;
+        args: string[] | undefined;
+        cwd: string | undefined;
+        env: Record<string, string> | undefined;
+        result: {
+            stdout: string;
+            stderr: string;
+            exitCode: number;
+            signal: Signal | undefined;
+            success: boolean;
+            failure: boolean;
+        } | undefined;
+    };
+}
+
+declare class NodeRuntime {
+    tmpDir: Path;
+    static Name: string;
+    private client;
+    private alreadyInstalled;
+    private localNode;
+    private localNpm;
+    constructor(tmpDir: Path);
+    isNodeInstalledGlobally(): Promise<boolean>;
+    isNodeInstalledLocally(): Promise<boolean>;
+    isNpmInstalledGlobally(): Promise<boolean>;
+    isNpmInstalledLocally(): Promise<boolean>;
+    nodeCmd(): Promise<string>;
+    nodePath(): Promise<string | null>;
+    npmCmd(): Promise<string>;
+    npmPath(): Promise<string | null>;
+    installIfNeeded(): Promise<string | undefined>;
+    install(): Promise<string>;
+    listPackages(): Promise<string[]>;
+    downloadNodePackage(platform: string, arch: string): Promise<string>;
+    unzipPackage(packagePath: string): Promise<string>;
+    npmInstall(omitDev?: boolean, cwd?: string): Promise<CommandResult>;
+    npm(npmArgs: string, cwd?: string): Promise<CommandResult>;
+    node(nodeArgs: string, cwd?: string): Promise<CommandResult>;
+}
+
+/**
+ * An object representing the mapping of expected output (as a regex string)
+ * to the input that should be provided in response.
+ */
+type InputMap = Record<string, string>;
+declare const CHECKMARK = "\u2713";
+declare const XMARK = "\u2717";
+/**
+ * A collection of regular expressions to detect various sudo/doas password prompts
+ * across different operating systems.
+ */
+declare const SUDO_PROMPT_REGEX: {
+    /**
+     * Matches the default sudo prompt on most Linux distributions.
+     * Example: `[sudo] password for <username>:`
+     */
+    LINUX: string;
+    /**
+     * Matches the default sudo prompt on macOS and some BSD systems.
+     * Example: `Password:`
+     */
+    MAC_BSD: string;
+    /**
+     * Matches the default prompt for `doas` on OpenBSD.
+     * Example: `doas (username@hostname) password:`
+     */
+    DOAS: string;
+};
+/**
+ * A helper function that builds an input map to handle various sudo/doas password prompts.
+ * This is useful for building up interaction handlers for commands that require privilege escalation
+ * across different operating systems.
+ *
+ * @param password The sudo/doas password to provide.
+ * @param existingInputMap An optional existing map of interactions.
+ * @returns A new input map containing the sudo/doas prompt interactions and any existing interactions.
+ */
+declare function withSudo(password: string | undefined, existingInputMap?: InputMap): InputMap;
+
+declare class InteractionHandler {
+    static with(inputs: InputMap): InteractionHandler;
+    private patternInputMappings;
+    private inputStreamForRegexMatcher;
+    private writeFn;
+    constructor(patternInputMappings?: Map<string | RegExp, string>);
+    clone(): InteractionHandler;
+    with(inputs: InputMap): InteractionHandler;
+    mapInput(inputMap: InputMap): InteractionHandler;
+    map(pattern: RegExp | string, response: string): this;
+    compositeRegex(): RegExp | undefined;
+    firstMatchingPattern(matchStr: string): string | undefined;
+    findReplacementForMatch(matchStr: string): string | undefined;
+    begin(): void;
+    handleInput(inputChunk: string): void;
+    setOutputToNewReadable(): Readable;
+    setOutputWriter(writeFn: (str: string) => void): void;
+    private emitInput;
+    end(): void;
+}
+
+type LogLevel = number;
+interface FileSystemOperations$1 {
+    read: (path: string) => Promise<string>;
+    write: (path: string, content: string, options?: {
+        mode?: string | number;
+        user?: string;
+        group?: string;
+    }) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    mkdir: (path: string, options?: {
+        recursive?: boolean;
+        mode?: string | number;
+    }) => Promise<void>;
+    rm: (path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }) => Promise<void>;
+}
+interface TaskContext<TParams extends TaskParams = TaskParams> {
+    params: TParams;
+    readonly id: string;
+    readonly host?: Host;
+    readonly config: AppConfig;
+    log: (level: LogLevel, ...message: any[]) => void;
+    info: (...message: any[]) => void;
+    debug: (...message: any[]) => void;
+    warn: (...message: any[]) => void;
+    error: (...message: any[]) => void;
+    exec: (command: string | string[], options?: {
+        input?: Record<string, string>;
+        sudo?: boolean;
+        stdin?: string | Buffer;
+        env?: EnvVarObj;
+        cwd?: string;
+        user?: string;
+        pty?: boolean;
+    }) => Promise<CommandResult>;
+    ssh: <TRemoteParams extends TaskParams = {}, TRemoteReturn extends RunFnReturnValue = RunFnReturnValue>(tags: string[], remoteTaskFn: (remoteContext: TaskContext<TRemoteParams>) => Promise<TRemoteReturn>) => Promise<Record<string, TRemoteReturn | Error>>;
+    run: <TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>) => Promise<TRunReturn>;
+    getPassword: () => Promise<string | undefined>;
+    getSecret: (name: string) => Promise<string | undefined>;
+    exit: (exitCode: number, message?: string) => void;
+    inventory: (tags: string[]) => Host[];
+    file: FileSystemOperations$1;
+}
+type TaskPartialFn<TReturn extends RunFnReturnValue = RunFnReturnValue> = (parentInvocation: IInvocation) => Promise<TReturn>;
+interface TaskFn<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
+    (params?: TParams): TaskPartialFn<TReturn>;
+    task: Task<TParams, TReturn>;
+}
+declare function task<TParams extends TaskParams, TReturn extends RunFnReturnValue>(runFn: RunFn<TParams, TReturn>, options?: {
+    description?: string;
+    name?: string;
+}): TaskFn<TParams, TReturn>;
+interface IInvocation<TParams extends TaskParams = any> {
+    id: string;
+    runtime: IRuntime;
+    host?: Host;
+    readonly config: AppConfig;
+    log(level: LogLevel, ...message: any[]): void;
+    info(...message: any[]): void;
+    debug(...message: any[]): void;
+    warn(...message: any[]): void;
+    error(...message: any[]): void;
+    exec(command: string | string[], options?: {
+        input?: Record<string, string>;
+        sudo?: boolean;
+        stdin?: string | Buffer;
+        env?: EnvVarObj;
+        cwd?: string;
+        user?: string;
+        pty?: boolean;
+    }): Promise<CommandResult>;
+    readonly file: FileSystemOperations$1;
+    ssh<TRemoteParams extends TaskParams = {}, TRemoteReturn extends RunFnReturnValue = RunFnReturnValue>(tags: string[], remoteTaskFn: (remoteContext: TaskContext<TRemoteParams>) => Promise<TRemoteReturn>): Promise<Record<string, TRemoteReturn | Error>>;
+    run<TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>): Promise<TRunReturn>;
+    invokeChildTask<TTaskParams extends TaskParams, TTaskReturn extends RunFnReturnValue>(childTaskFn: TaskFn<TTaskParams, TTaskReturn>, params: TTaskParams): Promise<TTaskReturn>;
+    getPassword(): Promise<string | undefined>;
+    getSecret(name: string): Promise<string | undefined>;
+    exit(exitCode: number, message?: string): void;
+    inventory(tags: string[]): Host[];
+    setDescription(description: string): void;
+    setFutureResult(resultPromise: Promise<RunFnReturnValue>): void;
+    appendChildInvocation(childInvocation: IInvocation<any>): Promise<void>;
+    readonly stderr: string;
+    readonly stdout: string;
+    resultError(): Promise<Error | undefined>;
+    getDescription(): string | undefined;
+    getChildren(): ReadonlyArray<IInvocation<any>>;
+    getResultPromise(): Promise<RunFnReturnValue>;
+}
+declare abstract class Invocation<TParams extends TaskParams = any> implements IInvocation<TParams> {
+    runtime: IRuntime;
+    taskFnDefinition: TaskFn<TParams, any>;
+    parent?: IInvocation<any> | undefined;
+    id: string;
+    children: Array<IInvocation<any>>;
+    private childrenMutex;
+    description?: string;
+    stderrSB: StringBuilder;
+    stdoutSB: StringBuilder;
+    host?: Host;
+    result: Promise<RunFnReturnValue>;
+    resolveResult: (value: RunFnReturnValue | PromiseLike<RunFnReturnValue>) => void;
+    rejectResult: (reason?: any) => void;
+    constructor(runtime: IRuntime, taskFnDefinition: TaskFn<TParams, any>, parent?: IInvocation<any> | undefined);
+    getPassword(): Promise<string | undefined>;
+    getSecret(name: string): Promise<string | undefined>;
+    get stderr(): string;
+    get stdout(): string;
+    info(...message: any[]): void;
+    debug(...message: any[]): void;
+    warn(...message: any[]): void;
+    error(...message: any[]): void;
+    resultError(): Promise<Error | undefined>;
+    setDescription(description: string): void;
+    setFutureResult(resultPromise: Promise<RunFnReturnValue>): void;
+    getDescription(): string | undefined;
+    getChildren(): ReadonlyArray<IInvocation<any>>;
+    getResultPromise(): Promise<RunFnReturnValue>;
+    exit(exitCode: number, message?: string): void;
+    inventory(tags: string[]): Host[];
+    appendChildInvocation(childInvocation: IInvocation<any>): Promise<void>;
+    abstract readonly config: AppConfig;
+    abstract log(level: LogLevel, ...message: any[]): void;
+    abstract exec(command: string | string[], options?: {
+        input?: Record<string, string>;
+        sudo: boolean;
+        stdin?: string | Buffer;
+        env?: EnvVarObj;
+        cwd?: string;
+        user?: string;
+        pty?: boolean;
+    }): Promise<CommandResult>;
+    abstract readonly file: FileSystemOperations$1;
+    abstract ssh<TRemoteParams extends TaskParams = {}, TRemoteReturn extends RunFnReturnValue = RunFnReturnValue>(tags: string[], remoteTaskFn: (remoteContext: TaskContext<TRemoteParams>) => Promise<TRemoteReturn>): Promise<Record<string, TRemoteReturn | Error>>;
+    abstract run<TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>): Promise<TRunReturn>;
+    abstract invokeChildTask<TTaskParams extends TaskParams, TTaskReturn extends RunFnReturnValue>(childTaskFn: TaskFn<TTaskParams, TTaskReturn>, params: TTaskParams): Promise<TTaskReturn>;
+}
+interface IRuntime {
+    app: App;
+    config?: {
+        cwd?: string;
+        configFile?: ConfigFile;
+    };
+    interactionHandler: InteractionHandler;
+    tmpDirRootPath: Path;
+    getPassword(): Promise<string | undefined>;
+    getSecret(name: string): Promise<string | undefined>;
+    getTmpDir(): Path;
+    getTmpFile(prefix?: string, postfix?: string, dir?: Path): Path;
+    inventory(tags: string[]): Host[];
+    invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams, description?: string): Promise<IInvocation<TParams>>;
+}
+
+/**
+ * Generic object type for parameters and return values.
+ */
+type ObjectType = {
+    [key: string]: any;
+};
+/**
+ * Base type for task-specific parameters.
+ */
+type TaskParams = ObjectType;
+/**
+ * Represents the possible return values of a task's run function.
+ */
+type RunFnReturnValue = ObjectType | void | undefined | null | Error;
+/**
+ * Defines the signature of a task's main execution function.
+ * It receives a TaskContext and returns a Promise of a RunFnReturnValue.
+ */
+interface RunFn<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
+    (context: TaskContext<TParams>): Promise<TReturn>;
+}
+/**
+ * Represents a task definition, including its run function and metadata.
+ * This class is instantiated by the `task` factory function.
+ */
+declare class Task<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
+    runFn: RunFn<TParams, TReturn>;
+    taskModuleAbsolutePath?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    constructor(runFn: RunFn<TParams, TReturn>, taskModuleAbsolutePath?: string | undefined, description?: string | undefined, name?: string | undefined);
+}
+
+interface FileSystemOperations {
+    read: (path: string) => Promise<string>;
+    write: (path: string, content: string, options?: {
+        mode?: string | number | undefined;
+        user?: string | undefined;
+        group?: string | undefined;
+    }) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    mkdir: (path: string, options?: {
+        recursive?: boolean | undefined;
+        mode?: string | number | undefined;
+    }) => Promise<void>;
+    rm: (path: string, options?: {
+        recursive?: boolean | undefined;
+        force?: boolean | undefined;
+    }) => Promise<void>;
+}
+declare class LocalInvocation<TParams extends TaskParams, TReturn extends RunFnReturnValue> extends Invocation<TParams> {
+    runtime: LocalRuntime;
+    taskFnDefinition: TaskFn<TParams, TReturn>;
+    readonly config: AppConfig;
+    readonly file: FileSystemOperations;
+    constructor(runtime: LocalRuntime, taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams, parent?: IInvocation<any>);
+    log(level: LogLevel, ...message: any[]): void;
+    exec(command: string | string[], options?: {
+        input?: Record<string, string>;
+        sudo?: boolean;
+        stdin?: string | Buffer;
+        env?: EnvVarObj;
+        cwd?: string;
+        user?: string;
+        pty?: boolean;
+    }): Promise<CommandResult>;
+    ssh<TRemoteParams extends TaskParams = {}, TRemoteReturn extends RunFnReturnValue = RunFnReturnValue>(tags: string[], remoteTaskFn: (remoteContext: TaskContext<TRemoteParams>) => Promise<TRemoteReturn>): Promise<Record<string, TRemoteReturn | Error>>;
+    runRemoteTaskOnHost<TRemoteParams extends TaskParams, TRemoteReturn extends RunFnReturnValue>(host: Host, remoteTaskFn: RunFn<TRemoteParams, TRemoteReturn>): Promise<TRemoteReturn | Error>;
+    exit(exitCode: number, message?: string): void;
+    inventory(tags: string[]): Host[];
+    run<TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>): Promise<TRunReturn>;
+    invokeChildTask<TTaskParams extends TaskParams, TTaskReturn extends RunFnReturnValue>(childTaskFnDefinition: TaskFn<TTaskParams, TTaskReturn>, params: TTaskParams): Promise<TTaskReturn>;
+}
+declare class LocalRuntime implements IRuntime {
+    app: App;
+    localBundlePath: Path;
+    interactionHandler: InteractionHandler;
+    config?: {
+        cwd?: string;
+        configFile?: ConfigFile;
+    };
+    host: Host;
+    private memoizedPassword?;
+    constructor(app: App, localBundlePath: Path, interactionHandler?: InteractionHandler);
+    get tmpDirRootPath(): Path;
+    getPassword(): Promise<string | undefined>;
+    getSecret(name: string): Promise<string | undefined>;
+    getTmpDir(): Path;
+    getTmpFile(prefix?: string | undefined, postfix?: string | undefined, dir?: Path | undefined): Path;
+    inventory(tags: string[]): Host[];
+    invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams, description?: string): Promise<LocalInvocation<TParams, TReturn>>;
+}
+
+declare class RemoteRuntime implements IRuntime {
+    private sftpClientInstance?;
+    readonly app: App;
+    readonly host: Host;
+    readonly interactionHandler: InteractionHandler;
+    private sshSession;
+    constructor(app: App, host: Host, _localRuntime: LocalRuntime, interactionHandler?: InteractionHandler);
+    get tmpDirRootPath(): Path;
+    getPassword(): Promise<string | undefined>;
+    getSecret(name: string): Promise<string | undefined>;
+    getTmpDir(): Path;
+    getTmpFile(prefix?: string | undefined, postfix?: string | undefined, dir?: Path | undefined): Path;
+    inventory(tags: string[]): Host[];
+    connect(): Promise<boolean>;
+    getSftpClient(): Promise<any>;
+    executeCommand(command: string | string[], options?: {
+        cwd?: string;
+        stdin?: string | Buffer;
+        pty?: boolean;
+        env?: Record<string, string>;
+        interactionHandler?: InteractionHandler;
+    }): Promise<Command | Error>;
+    disconnect(): Promise<void>;
+    invokeRootTask<TParams extends TaskParams, TReturn extends RunFnReturnValue>(taskFnDefinition: TaskFn<TParams, TReturn>, params: TParams): Promise<IInvocation>;
+}
+
+type AppConfig = Config;
+
+type TaskTreeNode = {
+    id: string;
+    parentId: string | null;
+    parent: TaskTreeNode | undefined;
+    children: Set<TaskTreeNode>;
+    name: string;
+    result?: Promise<string | Error | undefined>;
+};
+declare class TaskTree {
+    private listr;
+    private subLists;
+    private nodes;
+    private mutex;
+    constructor();
+    clear(): void;
+    add(id: string, parentId: string | null, name: string, result?: Promise<string | Error | undefined>): Promise<TaskTreeNode>;
+    get(id: string): TaskTreeNode | undefined;
+    getWithTimeout(id: string): Promise<TaskTreeNode | undefined>;
+    run(ctx?: any): Promise<any>;
+}
+declare const Verbosity: {
+    ERROR: number;
+    WARN: number;
+    INFO: number;
+    DEBUG: number;
+    TRACE: number;
+};
+declare class App {
+    configRef?: string;
+    private _config?;
+    selectedTags: Set<string>;
+    private outputStyle;
+    private _tmpDir?;
+    private tmpFileRegistry;
+    taskTree: TaskTree;
+    verbosity: number;
+    constructor();
+    appExitCallback(): void;
+    get config(): Config;
+    get tmpDir(): Path;
+    loadConfig(configString?: string): Promise<void>;
+    log(level: LogLevel, ...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    osHomeDir(): Path;
+    hostctlDir(): Path;
+    hostctlTmpDir(): Path;
+    randName(): string;
+    hostctlTmpPath(tmpName?: string): Path;
+    createNamedTmpDir(subDirName?: string): Path;
+    writeTmpFile(fileContent: string): Path;
+    shouldRunRemote(): boolean;
+    logHostCommandResult(host: Host, command: string | string[], cmdOrErr: Command | Error, isErrorResult?: boolean): void;
+    defaultSshUser(): string | undefined;
+    execute(cmd: string | string[]): Promise<boolean>;
+    runRemote(host: Host, cmd: string | string[]): Promise<Command | Error>;
+    getSecretsForHost(hostId: string): Map<string | RegExp, string>;
+    taskContextForRunFn<TParams extends TaskParams>(invocation: IInvocation<TParams>, params: TParams, hostForContext?: Host): TaskContext<TParams>;
+    setSelectedTags(selectedTags: string[]): void;
+    setOutputStyle(outputStyle: 'plain' | 'json'): void;
+    setVerbosity(level: number): void;
+    outputJson(): boolean;
+    outputPlain(): boolean;
+    querySelectedInventory(tags?: string[]): Host[];
+    selectedInventory(): Host[];
+    queryInventory(tags?: Set<string>): Host[];
+    selectInventory(hosts: Host[], tags?: Set<string>): Host[];
+    printInventoryReport(): void;
+    encryptInventoryFile(): Promise<void>;
+    decryptInventoryFile(): Promise<void>;
+    runScript(scriptRef: string, params: TaskParams): Promise<void>;
+    runScriptRemote(scriptRef: string, params: TaskParams): Promise<void>;
+    walkInvocationTreePreorder(invocation: IInvocation<any>, visitFn: (invocation: IInvocation<any>, depth: number) => Promise<void>, visited?: Set<IInvocation<any>>, depth?: number): Promise<void>;
+    reportScriptResult(invocation: LocalInvocation<any, any>, scriptResult: RunFnReturnValue | Error): Promise<void>;
+    loadScriptAsModule(scriptRef: string): Promise<any>;
+    parseParams(scriptArgs: string[]): Object;
+    bundleProject(entrypointPath: string): Promise<void>;
+    generateBundle(nodeRuntime: NodeRuntime, packageFileDir: Path): Promise<Path>;
+    pathOfPackageJsonFile(path: string): Path | null;
+    printRuntimeReport(): Promise<void>;
+    promptPassword(message?: string): Promise<string>;
+    installRuntime(): Promise<void>;
+    bootstrap(): Promise<void>;
+}
+
+declare class Cli {
+    app: App;
+    program: cmdr.Command;
+    constructor();
+    handleBundle(path: string, options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleInventory(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleInventoryEncrypt(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleInventoryDecrypt(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleInventoryList(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleExec(commandParts: string | string[], options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleRun(packageOrBundle: string | null, scriptRef: string | undefined, scriptArgs: string[], options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    deriveConfigRef(suppliedConfigRef?: string): string;
+    loadApp(opts: Record<string, any>): Promise<void>;
+    run(): Promise<void>;
+    handleRuntime(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+    handleRuntimeInstall(options: Record<string, any>, cmd: cmdr.Command): Promise<void>;
+}
+
+interface WhoamiParams {
+}
+interface WhoamiResult {
+    user: string;
+}
+
+type EchoParams = {
+    args: string[];
+};
+interface EchoResult {
+    stdout: string;
+}
+
+interface DirExistsParams {
+    path: string;
+}
+interface DirExistsResult {
+    exists: boolean;
+}
+declare const _default$$: TaskFn<DirExistsParams, DirExistsResult>;
+
+interface DirCopyParams {
+    from: string;
+    to: string;
+    mode?: string;
+    owner?: string;
+    group?: string;
+    sudo?: boolean;
+}
+interface DirCopyResult {
+    success: boolean;
+}
+declare const _default$_: TaskFn<DirCopyParams, DirCopyResult>;
+
+interface DirCreateParams {
+    path: string;
+    mode?: string;
+    owner?: string;
+}
+interface DirCreateResult {
+    success: boolean;
+}
+declare const _default$Z: TaskFn<DirCreateParams, DirCreateResult>;
+
+declare namespace dir {
+  export { _default$_ as copy, _default$Z as create, _default$$ as exists };
+}
+
+interface ChownParams {
+    path: string;
+    owner: string;
+    group?: string;
+    recursive?: boolean;
+    sudo?: boolean;
+}
+interface ChownResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$Y: TaskFn<ChownParams, ChownResult>;
+
+interface ChgrpParams {
+    path: string;
+    group: string;
+    recursive?: boolean;
+    sudo?: boolean;
+}
+interface ChgrpResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$X: TaskFn<ChgrpParams, ChgrpResult>;
+
+interface ChmodParams {
+    path: string;
+    mode: string | number;
+    recursive?: boolean;
+    sudo?: boolean;
+}
+interface ChmodResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$W: TaskFn<ChmodParams, ChmodResult>;
+
+interface FileCopyParams {
+    from: string;
+    to: string;
+    mode?: string;
+    owner?: string;
+    group?: string;
+    recursive?: boolean;
+    sudo?: boolean;
+}
+interface FileCopyResult {
+    success: boolean;
+}
+declare const _default$V: TaskFn<FileCopyParams, FileCopyResult>;
+
+interface FileExistsParams {
+    path: string;
+}
+interface FileExistsResult {
+    exists: boolean;
+}
+declare const _default$U: TaskFn<FileExistsParams, FileExistsResult>;
+
+interface FileTouchParams {
+    file: string;
+    mode?: string;
+    owner?: string;
+}
+interface FileTouchResult {
+    success: boolean;
+}
+declare const _default$T: TaskFn<FileTouchParams, FileTouchResult>;
+
+interface FileDeleteParams {
+    path: string;
+    recursive?: boolean;
+    force?: boolean;
+}
+interface FileDeleteResult {
+    success: boolean;
+}
+declare const _default$S: TaskFn<FileDeleteParams, FileDeleteResult>;
+
+interface FileLinkParams {
+    /** Path the symlink should point TO (target). */
+    target: string;
+    /** Path of the symlink itself. */
+    link: string;
+    /** Overwrite existing link/file if necessary (default true) */
+    force?: boolean;
+    /** Use sudo when creating/modifying (default false) */
+    sudo?: boolean;
+}
+interface FileLinkResult {
+    changed: boolean;
+    success: boolean;
+}
+declare const _default$R: TaskFn<FileLinkParams, FileLinkResult>;
+
+interface FileEditParams {
+    file: string;
+    state?: 'present' | 'absent';
+    backup?: boolean;
+    sudo?: boolean;
+    append?: string;
+    line?: string;
+    regex?: string;
+    after?: string;
+    before?: string;
+    block?: string;
+    marker_begin?: string;
+    marker_end?: string;
+}
+interface FileEditResult {
+    changed: boolean;
+    success: boolean;
+}
+declare const _default$Q: TaskFn<FileEditParams, FileEditResult>;
+
+interface FileGrepParams {
+    /** Path to the file to search */
+    file: string;
+    /** Pattern to search for (POSIX extended regex passed to grep -E) */
+    pattern: string;
+    /** If true, perform a case-insensitive match (adds -i flag). Default: false */
+    ignore_case?: boolean;
+    /** If true, show only lines that do NOT match (grep -v). Default: false */
+    invert_match?: boolean;
+    /** Match whole words only (grep -w). Default: false */
+    whole_word?: boolean;
+    /** Treat pattern as a fixed string, not regex (grep -F). Default: false */
+    fixed_string?: boolean;
+    /** Include line numbers in output (grep -n). Default: false */
+    line_numbers?: boolean;
+    /** Lines of context before each match (grep -B) */
+    before_context?: number;
+    /** Lines of context after each match (grep -A) */
+    after_context?: number;
+    /** Lines of context before & after (grep -C) */
+    context?: number;
+    /** Stop reading after NUM matching lines (grep -m) */
+    max_count?: number;
+    /** Return the matching lines in the result payload. Default: false */
+    return_lines?: boolean;
+}
+interface FileGrepResult {
+    /** True if one or more matches were found */
+    found: boolean;
+    /** Number of matching lines */
+    count: number;
+    /** Matching lines (included only when return_lines=true) */
+    lines?: string[];
+}
+declare const _default$P: TaskFn<FileGrepParams, FileGrepResult>;
+
+type file_ChgrpParams = ChgrpParams;
+type file_ChgrpResult = ChgrpResult;
+type file_ChmodParams = ChmodParams;
+type file_ChmodResult = ChmodResult;
+type file_ChownParams = ChownParams;
+type file_ChownResult = ChownResult;
+type file_FileCopyParams = FileCopyParams;
+type file_FileCopyResult = FileCopyResult;
+type file_FileDeleteParams = FileDeleteParams;
+type file_FileDeleteResult = FileDeleteResult;
+type file_FileEditParams = FileEditParams;
+type file_FileEditResult = FileEditResult;
+type file_FileExistsParams = FileExistsParams;
+type file_FileExistsResult = FileExistsResult;
+type file_FileGrepParams = FileGrepParams;
+type file_FileGrepResult = FileGrepResult;
+type file_FileLinkParams = FileLinkParams;
+type file_FileLinkResult = FileLinkResult;
+type file_FileTouchParams = FileTouchParams;
+type file_FileTouchResult = FileTouchResult;
+declare namespace file {
+  export { type file_ChgrpParams as ChgrpParams, type file_ChgrpResult as ChgrpResult, type file_ChmodParams as ChmodParams, type file_ChmodResult as ChmodResult, type file_ChownParams as ChownParams, type file_ChownResult as ChownResult, type file_FileCopyParams as FileCopyParams, type file_FileCopyResult as FileCopyResult, type file_FileDeleteParams as FileDeleteParams, type file_FileDeleteResult as FileDeleteResult, type file_FileEditParams as FileEditParams, type file_FileEditResult as FileEditResult, type file_FileExistsParams as FileExistsParams, type file_FileExistsResult as FileExistsResult, type file_FileGrepParams as FileGrepParams, type file_FileGrepResult as FileGrepResult, type file_FileLinkParams as FileLinkParams, type file_FileLinkResult as FileLinkResult, type file_FileTouchParams as FileTouchParams, type file_FileTouchResult as FileTouchResult, _default$X as chgrp, _default$W as chmod, _default$Y as chown, _default$V as copy, _default$S as delete, _default$Q as edit, _default$U as exists, _default$P as grep, _default$R as link, _default$T as touch };
+}
+
+interface GitCloneParams {
+    repo: string;
+    dir: string;
+}
+interface GitCloneResult {
+    success: boolean;
+}
+declare const _default$O: TaskFn<GitCloneParams, GitCloneResult>;
+
+interface GitPullParams {
+    /** The directory of the git repository on the host. */
+    directory: string;
+    /** Optional: Whether to use --rebase. Defaults to false. */
+    rebase?: boolean;
+    /** Optional: The remote to pull from. Defaults to 'origin'. */
+    remote?: string;
+    /** Optional: The branch to pull. Defaults to the current branch. */
+    branch?: string;
+}
+interface GitPullResult {
+    /** Indicates whether the pull operation was successful. */
+    success: boolean;
+    /** Error message if the pull operation failed. */
+    error?: string;
+}
+declare const _default$N: TaskFn<GitPullParams, GitPullResult>;
+
+interface GitCheckoutParams {
+    /** The directory of the git repository on the host. */
+    directory: string;
+    /** The branch, tag, or commit hash to checkout. */
+    target: string;
+    /** Optional: If true, creates a new branch named <target> before checking out. Defaults to false. */
+    new_branch?: boolean;
+}
+interface GitCheckoutResult {
+    /** Indicates whether the checkout operation was successful. */
+    success: boolean;
+    /** Error message if the checkout operation failed. */
+    error?: string;
+}
+declare const _default$M: TaskFn<GitCheckoutParams, GitCheckoutResult>;
+
+type git_GitCheckoutParams = GitCheckoutParams;
+type git_GitCheckoutResult = GitCheckoutResult;
+type git_GitCloneParams = GitCloneParams;
+type git_GitCloneResult = GitCloneResult;
+type git_GitPullParams = GitPullParams;
+type git_GitPullResult = GitPullResult;
+declare namespace git {
+  export { type git_GitCheckoutParams as GitCheckoutParams, type git_GitCheckoutResult as GitCheckoutResult, type git_GitCloneParams as GitCloneParams, type git_GitCloneResult as GitCloneResult, type git_GitPullParams as GitPullParams, type git_GitPullResult as GitPullResult, _default$M as checkout, _default$O as clone, _default$N as pull };
+}
+
+interface GroupCreateParams {
+    group: string;
+    /** Whether to run the command with sudo. Defaults to true. */
+    sudo?: boolean;
+}
+interface GroupCreateResult {
+    success: boolean;
+}
+declare const _default$L: TaskFn<GroupCreateParams, GroupCreateResult>;
+
+interface GroupDeleteParams {
+    group: string;
+    /** Whether to run the command with sudo. Defaults to true. */
+    sudo?: boolean;
+}
+interface GroupDeleteResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$K: TaskFn<GroupDeleteParams, GroupDeleteResult>;
+
+interface GroupExistsParams {
+    group: string;
+}
+interface GroupExistsResult {
+    exists: boolean;
+}
+declare const _default$J: TaskFn<GroupExistsParams, GroupExistsResult>;
+
+interface GroupInfo {
+    name: string;
+    gid: number;
+}
+interface GroupListParams {
+}
+interface GroupListResult {
+    success: boolean;
+    groups: GroupInfo[];
+}
+declare const _default$I: TaskFn<GroupListParams, GroupListResult>;
+
+interface GroupModifyParams {
+    /** The current name of the group. */
+    group: string;
+    /** The new name for the group. */
+    new_name?: string;
+    /** The new numerical value of the group's ID. */
+    gid?: number;
+    /** Whether to run the command with sudo. Defaults to true. */
+    sudo?: boolean;
+}
+interface GroupModifyResult {
+    success: boolean;
+    changed: boolean;
+    error?: string;
+}
+declare const _default$H: TaskFn<GroupModifyParams, GroupModifyResult>;
+
+type group_GroupCreateParams = GroupCreateParams;
+type group_GroupCreateResult = GroupCreateResult;
+type group_GroupDeleteParams = GroupDeleteParams;
+type group_GroupDeleteResult = GroupDeleteResult;
+type group_GroupExistsParams = GroupExistsParams;
+type group_GroupExistsResult = GroupExistsResult;
+type group_GroupInfo = GroupInfo;
+type group_GroupListParams = GroupListParams;
+type group_GroupListResult = GroupListResult;
+type group_GroupModifyParams = GroupModifyParams;
+type group_GroupModifyResult = GroupModifyResult;
+declare namespace group {
+  export { type group_GroupCreateParams as GroupCreateParams, type group_GroupCreateResult as GroupCreateResult, type group_GroupDeleteParams as GroupDeleteParams, type group_GroupDeleteResult as GroupDeleteResult, type group_GroupExistsParams as GroupExistsParams, type group_GroupExistsResult as GroupExistsResult, type group_GroupInfo as GroupInfo, type group_GroupListParams as GroupListParams, type group_GroupListResult as GroupListResult, type group_GroupModifyParams as GroupModifyParams, type group_GroupModifyResult as GroupModifyResult, _default$L as create, _default$K as delete, _default$J as exists, _default$I as list, _default$H as modify };
+}
+
+interface OSInfo {
+    family: string;
+    base_os: string;
+    os: string;
+    version: string;
+}
+interface LSBRelease {
+    'Distributor ID': string;
+    Description: string;
+    Release: string;
+    Codename: string;
+}
+interface LSCPUChild {
+    field: string;
+    data: string;
+    children?: LSCPUChild[];
+}
+interface HostInfo {
+    name: string;
+    os: OSInfo;
+    lsb_release: LSBRelease;
+    lscpu: LSCPUChild[];
+}
+interface HostSummary {
+    name: string;
+    os: OSInfo;
+    cpu: string;
+}
+
+interface HostInfoResult {
+    host: HostInfo;
+}
+declare const _default$G: TaskFn<ObjectType, HostInfoResult>;
+
+interface HostSummaryResult {
+    host: HostSummary;
+}
+declare const _default$F: TaskFn<ObjectType, HostSummaryResult>;
+
+interface OsDetailsResult {
+    success: boolean;
+    error?: string;
+    family: 'bsd' | 'darwin' | 'linux' | 'solaris' | 'windows' | 'unknown';
+    /** The general OS type, e.g., 'debian', 'fedora', 'osx'. Derived from ID_LIKE in /etc/os-release for Linux. */
+    os: string;
+    /** The specific OS variant, e.g., 'ubuntu', 'arch'. Derived from ID in /etc/os-release for Linux. */
+    variant: string;
+    /** The OS version string. */
+    version: string;
+}
+/**
+ * Determines the operating system family, specific OS, variant, and version.
+ * @returns {OsDetailsResult}
+ */
+declare const _default$E: TaskFn<ObjectType, OsDetailsResult>;
+
+interface HostnameParams {
+    new_name?: string;
+}
+interface HostnameResult {
+    hostname: string;
+    updated: boolean;
+}
+declare const _default$D: TaskFn<HostnameParams, HostnameResult>;
+
+type host_HostInfo = HostInfo;
+type host_HostInfoResult = HostInfoResult;
+type host_HostSummary = HostSummary;
+type host_HostSummaryResult = HostSummaryResult;
+type host_HostnameParams = HostnameParams;
+type host_HostnameResult = HostnameResult;
+type host_LSBRelease = LSBRelease;
+type host_LSCPUChild = LSCPUChild;
+type host_OSInfo = OSInfo;
+type host_OsDetailsResult = OsDetailsResult;
+declare namespace host {
+  export { type host_HostInfo as HostInfo, type host_HostInfoResult as HostInfoResult, type host_HostSummary as HostSummary, type host_HostSummaryResult as HostSummaryResult, type host_HostnameParams as HostnameParams, type host_HostnameResult as HostnameResult, type host_LSBRelease as LSBRelease, type host_LSCPUChild as LSCPUChild, type host_OSInfo as OSInfo, type host_OsDetailsResult as OsDetailsResult, _default$D as hostname, _default$G as info, _default$E as os, _default$F as summary };
+}
+
+interface BasePkgParams {
+    /** Package name or array of package names */
+    package: string | string[];
+    /** Run commands with sudo (default true) */
+    sudo?: boolean;
+}
+interface PkgInstallParams extends BasePkgParams {
+}
+interface PkgRemoveParams extends BasePkgParams {
+}
+interface PkgInstallResult {
+    success: boolean;
+    error?: string;
+}
+interface PkgRemoveResult {
+    success: boolean;
+    error?: string;
+}
+interface PkgUpdateParams {
+    /** Optional package name(s) to upgrade. Omit to upgrade all packages on the system */
+    package?: string | string[];
+    /** Run commands with sudo (default true) */
+    sudo?: boolean;
+    /** If true perform a full/dist upgrade when supported */
+    fullUpgrade?: boolean;
+}
+interface PkgUpdateResult {
+    success: boolean;
+    error?: string;
+}
+interface PkgIsInstalledParams {
+    package: string;
+}
+interface PkgIsInstalledResult {
+    installed: boolean;
+}
+
+declare const _default$C: TaskFn<PkgInstallParams, PkgInstallResult>;
+
+declare const _default$B: TaskFn<PkgRemoveParams, PkgRemoveResult>;
+
+declare const _default$A: TaskFn<PkgUpdateParams, PkgUpdateResult>;
+
+interface PkgInfoParams {
+    package: string;
+}
+interface PkgInfoResult {
+    installed: boolean;
+    success: boolean;
+    error?: string;
+}
+declare const _default$z: TaskFn<PkgInfoParams, PkgInfoResult>;
+
+declare const _default$y: TaskFn<PkgIsInstalledParams, PkgIsInstalledResult>;
+
+type pkg_PkgInfoParams = PkgInfoParams;
+type pkg_PkgInfoResult = PkgInfoResult;
+type pkg_PkgInstallParams = PkgInstallParams;
+type pkg_PkgInstallResult = PkgInstallResult;
+type pkg_PkgIsInstalledParams = PkgIsInstalledParams;
+type pkg_PkgIsInstalledResult = PkgIsInstalledResult;
+type pkg_PkgRemoveParams = PkgRemoveParams;
+type pkg_PkgRemoveResult = PkgRemoveResult;
+type pkg_PkgUpdateParams = PkgUpdateParams;
+type pkg_PkgUpdateResult = PkgUpdateResult;
+declare namespace pkg {
+  export { type pkg_PkgInfoParams as PkgInfoParams, type pkg_PkgInfoResult as PkgInfoResult, type pkg_PkgInstallParams as PkgInstallParams, type pkg_PkgInstallResult as PkgInstallResult, type pkg_PkgIsInstalledParams as PkgIsInstalledParams, type pkg_PkgIsInstalledResult as PkgIsInstalledResult, type pkg_PkgRemoveParams as PkgRemoveParams, type pkg_PkgRemoveResult as PkgRemoveResult, type pkg_PkgUpdateParams as PkgUpdateParams, type pkg_PkgUpdateResult as PkgUpdateResult, _default$z as info, _default$C as install, _default$y as isInstalled, _default$B as remove, _default$A as update };
+}
+
+interface K3supInstallParams {
+    cluster?: boolean;
+    context?: string;
+    datastore?: string;
+    /** Public hostname of node on which to install k3s (k3sup --host) */
+    targetHost?: string;
+    /** Public IP of node (k3sup --ip) */
+    ip?: string;
+    ipsec?: boolean;
+    k3sChannel?: string;
+    k3sExtraArgs?: string;
+    k3sVersion?: string;
+    local?: boolean;
+    localPath?: string;
+    merge?: boolean;
+    noExtras?: boolean;
+    printCommand?: boolean;
+    printConfig?: boolean;
+    skipInstall?: boolean;
+    sshKey?: string;
+    sshPort?: number;
+    sudo?: boolean;
+    tlsSan?: string;
+    token?: string;
+    /** Username for SSH login (k3sup --user) */
+    user?: string;
+}
+interface K3supInstallResult {
+    stdout: string;
+    stderr: string;
+    /** Kubeconfig content if --print-config was used */
+    kubeconfig?: string;
+    /** The command that would be run if --print-command was used */
+    executedCommand?: string;
+}
+declare const _default$x: TaskFn<K3supInstallParams, K3supInstallResult>;
+
+type k3s_K3supInstallParams = K3supInstallParams;
+type k3s_K3supInstallResult = K3supInstallResult;
+declare namespace k3s {
+  export { type k3s_K3supInstallParams as K3supInstallParams, type k3s_K3supInstallResult as K3supInstallResult, _default$x as k3supInstall };
+}
+
+interface CopyIdParams {
+    public_key: string;
+    user?: string;
+}
+interface CopyIdResult {
+    success: boolean;
+}
+declare const _default$w: TaskFn<CopyIdParams, CopyIdResult>;
+
+declare namespace ssh {
+  export { _default$w as copy_id };
+}
+
+interface SudoersCheckParams {
+    file?: string;
+}
+interface SudoersCheckResult {
+    success: boolean;
+}
+declare const _default$v: TaskFn<SudoersCheckParams, SudoersCheckResult>;
+
+interface GrantNopasswdParams {
+    /** The username to grant passwordless sudo privileges. */
+    user: string;
+    /** The name of the file to create in /etc/sudoers.d/. Defaults to the username. */
+    name?: string;
+}
+interface GrantNopasswdResult {
+    /** True if the operation was successful. */
+    success: boolean;
+    /** The path to the created sudoers file. */
+    filePath: string;
+}
+declare const _default$u: TaskFn<GrantNopasswdParams, GrantNopasswdResult>;
+
+declare namespace sudoers {
+  export { _default$v as check, _default$u as grantNopasswd };
+}
+
+interface RebootParams {
+    /**
+     * A message to broadcast to all users before rebooting.
+     */
+    message?: string;
+    /**
+     * The time to wait before rebooting. E.g., "+5" for 5 minutes, "now" for immediately.
+     * @default "now"
+     */
+    time?: string;
+    /**
+     * Whether to run the command with sudo. Defaults to true.
+     */
+    sudo?: boolean;
+}
+interface RebootResult {
+    success: boolean;
+    error?: string;
+    status: string;
+}
+declare const _default$t: TaskFn<RebootParams, RebootResult>;
+
+interface ShutdownParams {
+    /**
+     * A message to broadcast to all users before shutting down.
+     */
+    message?: string;
+    /**
+     * The time to wait before shutting down. E.g., "+5" for 5 minutes, "now" for immediately.
+     * @default "now"
+     */
+    time?: string;
+    /**
+     * Whether to run the command with sudo. Defaults to true.
+     */
+    sudo?: boolean;
+}
+interface ShutdownResult {
+    success: boolean;
+    error?: string;
+    status: string;
+}
+declare const _default$s: TaskFn<ShutdownParams, ShutdownResult>;
+
+interface RebootNeededParams {
+}
+interface RebootNeededResult {
+    reboot_needed: boolean;
+    success: boolean;
+    error?: string;
+}
+declare const _default$r: TaskFn<RebootNeededParams, RebootNeededResult>;
+
+interface RebootIfNeededParams {
+    delay?: number;
+    message?: string;
+}
+interface RebootIfNeededResult {
+    rebooting: boolean;
+    success: boolean;
+    error?: string;
+}
+declare const _default$q: TaskFn<RebootIfNeededParams, RebootIfNeededResult>;
+
+type system_RebootIfNeededParams = RebootIfNeededParams;
+type system_RebootIfNeededResult = RebootIfNeededResult;
+type system_RebootNeededParams = RebootNeededParams;
+type system_RebootNeededResult = RebootNeededResult;
+type system_RebootParams = RebootParams;
+type system_RebootResult = RebootResult;
+type system_ShutdownParams = ShutdownParams;
+type system_ShutdownResult = ShutdownResult;
+declare namespace system {
+  export { type system_RebootIfNeededParams as RebootIfNeededParams, type system_RebootIfNeededResult as RebootIfNeededResult, type system_RebootNeededParams as RebootNeededParams, type system_RebootNeededResult as RebootNeededResult, type system_RebootParams as RebootParams, type system_RebootResult as RebootResult, type system_ShutdownParams as ShutdownParams, type system_ShutdownResult as ShutdownResult, _default$t as reboot, _default$q as rebootIfNeeded, _default$r as rebootNeeded, _default$s as shutdown };
+}
+
+interface DisableServiceParams {
+    service: string;
+    sudo?: boolean;
+}
+interface DisableServiceResult {
+    success: boolean;
+}
+declare const _default$p: TaskFn<DisableServiceParams, DisableServiceResult>;
+
+interface SystemdEnableParams {
+    service: string;
+    sudo?: boolean;
+}
+interface SystemdEnableResult {
+    success: boolean;
+}
+declare const _default$o: TaskFn<SystemdEnableParams, SystemdEnableResult>;
+
+interface SystemdRestartParams {
+    service: string;
+    sudo?: boolean;
+}
+interface SystemdRestartResult {
+    success: boolean;
+}
+declare const _default$n: TaskFn<SystemdRestartParams, SystemdRestartResult>;
+
+interface SystemdStartParams {
+    service: string;
+    sudo?: boolean;
+}
+interface SystemdStartResult {
+    success: boolean;
+}
+declare const _default$m: TaskFn<SystemdStartParams, SystemdStartResult>;
+
+interface SystemdStopParams {
+    service: string;
+    sudo?: boolean;
+}
+interface SystemdStopResult {
+    success: boolean;
+}
+declare const _default$l: TaskFn<SystemdStopParams, SystemdStopResult>;
+
+interface SystemdReloadParams {
+    service: string;
+    sudo?: boolean;
+}
+interface SystemdReloadResult {
+    success: boolean;
+}
+declare const _default$k: TaskFn<SystemdReloadParams, SystemdReloadResult>;
+
+interface SystemdStatusParams {
+    service: string;
+    sudo?: boolean;
+}
+interface SystemdStatusResult {
+    active: boolean;
+}
+declare const _default$j: TaskFn<SystemdStatusParams, SystemdStatusResult>;
+
+declare namespace systemd {
+  export { _default$p as disable, _default$o as enable, _default$k as reload, _default$n as restart, _default$m as start, _default$j as status, _default$l as stop };
+}
+
+interface TemplateWriteParams {
+    template?: string;
+    template_file?: string;
+    variables: Record<string, any>;
+    to: string;
+    mode?: string;
+    owner?: string;
+    group?: string;
+    sudo?: boolean;
+}
+interface TemplateWriteResult {
+    success: boolean;
+    path: string;
+}
+declare const _default$i: TaskFn<TemplateWriteParams, TemplateWriteResult>;
+
+declare namespace template {
+  export { _default$i as write };
+}
+
+interface UfwDenyParams {
+    from_addr?: string;
+    from_port?: number;
+    to_addr?: string;
+    to_port?: number;
+}
+interface UfwDenyResult {
+    success: boolean;
+}
+declare const _default$h: TaskFn<UfwDenyParams, UfwDenyResult>;
+
+interface UfwDisableParams {
+}
+interface UfwDisableResult {
+    success: boolean;
+}
+declare const _default$g: TaskFn<UfwDisableParams, UfwDisableResult>;
+
+interface UfwEnableParams {
+}
+interface UfwEnableResult {
+    success: boolean;
+}
+declare const _default$f: TaskFn<UfwEnableParams, UfwEnableResult>;
+
+interface UfwInstallParams {
+}
+interface UfwInstallResult {
+    success: boolean;
+}
+declare const _default$e: TaskFn<UfwInstallParams, UfwInstallResult>;
+
+interface UfwReloadParams {
+}
+interface UfwReloadResult {
+    success: boolean;
+}
+declare const _default$d: TaskFn<UfwReloadParams, UfwReloadResult>;
+
+declare namespace ufw {
+  export { _default$h as deny, _default$g as disable, _default$f as enable, _default$e as install, _default$d as reload };
+}
+
+interface AddGroupsParams {
+    user: string;
+    groups: string[];
+}
+interface AddGroupsResult {
+    success: boolean;
+}
+declare const _default$c: TaskFn<AddGroupsParams, AddGroupsResult>;
+
+interface CreateUserParams {
+    user: string;
+    create_home?: boolean;
+    create_group?: boolean;
+    system?: boolean;
+    sudo?: boolean;
+}
+interface CreateUserResult {
+    success: boolean;
+}
+declare const _default$b: TaskFn<CreateUserParams, CreateUserResult>;
+
+interface UserExistsParams {
+    user: string;
+}
+interface UserExistsResult {
+    exists: boolean;
+}
+declare const _default$a: TaskFn<UserExistsParams, UserExistsResult>;
+
+interface GetGidParams {
+    user: string;
+}
+interface GetGidResult {
+    success: boolean;
+    gid: string;
+}
+declare const _default$9: TaskFn<GetGidParams, GetGidResult>;
+
+interface GetGroupsParams {
+    user: string;
+}
+interface GetGroupsResult {
+    success: boolean;
+    groups: string[];
+}
+declare const _default$8: TaskFn<GetGroupsParams, GetGroupsResult>;
+
+interface GetUidParams {
+    user: string;
+}
+interface GetUidResult {
+    success: boolean;
+    uid: string;
+}
+declare const _default$7: TaskFn<GetUidParams, GetUidResult>;
+
+interface GetUsernameResult {
+    success: boolean;
+    username: string;
+}
+declare const _default$6: TaskFn<{}, GetUsernameResult>;
+
+interface UserHomeDirParams {
+    user: string;
+}
+interface UserHomeDirResult {
+    path: string;
+    exists: boolean;
+}
+declare const _default$5: TaskFn<UserHomeDirParams, UserHomeDirResult>;
+
+interface SetUserGroupsParams {
+    user: string;
+    groups: string[];
+}
+interface SetUserGroupsResult {
+    success: boolean;
+}
+declare const _default$4: TaskFn<SetUserGroupsParams, SetUserGroupsResult>;
+
+interface SetUserShellParams {
+    user: string;
+    shell: string;
+}
+interface SetUserShellResult {
+    success: boolean;
+}
+declare const _default$3: TaskFn<SetUserShellParams, SetUserShellResult>;
+
+interface UserDeleteParams {
+    user: string;
+    /** If true, remove the user's home directory and mail spool. */
+    remove?: boolean;
+    /** Whether to run the command with sudo. Defaults to true. */
+    sudo?: boolean;
+}
+interface UserDeleteResult {
+    success: boolean;
+    error?: string;
+}
+declare const _default$2: TaskFn<UserDeleteParams, UserDeleteResult>;
+
+interface ModifyUserParams {
+    user: string;
+    comment?: string;
+    home?: string;
+    expiredate?: string;
+    gid?: string;
+    groups?: string[];
+    login?: string;
+    lock?: boolean;
+    unlock?: boolean;
+    move_home?: boolean;
+    shell?: string;
+    uid?: string;
+    sudo?: boolean;
+}
+interface ModifyUserResult {
+    success: boolean;
+}
+declare const _default$1: TaskFn<ModifyUserParams, ModifyUserResult>;
+
+type user_AddGroupsParams = AddGroupsParams;
+type user_AddGroupsResult = AddGroupsResult;
+type user_CreateUserParams = CreateUserParams;
+type user_CreateUserResult = CreateUserResult;
+type user_GetGidParams = GetGidParams;
+type user_GetGidResult = GetGidResult;
+type user_GetGroupsParams = GetGroupsParams;
+type user_GetGroupsResult = GetGroupsResult;
+type user_GetUidParams = GetUidParams;
+type user_GetUidResult = GetUidResult;
+type user_GetUsernameResult = GetUsernameResult;
+type user_SetUserGroupsParams = SetUserGroupsParams;
+type user_SetUserGroupsResult = SetUserGroupsResult;
+type user_SetUserShellParams = SetUserShellParams;
+type user_SetUserShellResult = SetUserShellResult;
+type user_UserDeleteParams = UserDeleteParams;
+type user_UserDeleteResult = UserDeleteResult;
+type user_UserExistsParams = UserExistsParams;
+type user_UserExistsResult = UserExistsResult;
+type user_UserHomeDirParams = UserHomeDirParams;
+type user_UserHomeDirResult = UserHomeDirResult;
+declare namespace user {
+  export { type user_AddGroupsParams as AddGroupsParams, type user_AddGroupsResult as AddGroupsResult, type user_CreateUserParams as CreateUserParams, type user_CreateUserResult as CreateUserResult, type user_GetGidParams as GetGidParams, type user_GetGidResult as GetGidResult, type user_GetGroupsParams as GetGroupsParams, type user_GetGroupsResult as GetGroupsResult, type user_GetUidParams as GetUidParams, type user_GetUidResult as GetUidResult, type user_GetUsernameResult as GetUsernameResult, type user_SetUserGroupsParams as SetUserGroupsParams, type user_SetUserGroupsResult as SetUserGroupsResult, type user_SetUserShellParams as SetUserShellParams, type user_SetUserShellResult as SetUserShellResult, type user_UserDeleteParams as UserDeleteParams, type user_UserDeleteResult as UserDeleteResult, type user_UserExistsParams as UserExistsParams, type user_UserExistsResult as UserExistsResult, type user_UserHomeDirParams as UserHomeDirParams, type user_UserHomeDirResult as UserHomeDirResult, _default$c as addGroups, _default$b as create, _default$2 as delete, _default$a as exists, _default$9 as getGid, _default$8 as getGroups, _default$7 as getUid, _default$6 as getUsername, _default$5 as homeDir, _default$1 as modify, _default$4 as setGroups, _default$3 as setShell };
+}
+
+declare const _default: {
+    echo: TaskFn<EchoParams, EchoResult>;
+    whoami: TaskFn<WhoamiParams, WhoamiResult>;
+    dir: typeof dir;
+    file: typeof file;
+    git: typeof git;
+    group: typeof group;
+    host: typeof host;
+    pkg: typeof pkg;
+    k3s: typeof k3s;
+    ssh: typeof ssh;
+    sudoers: typeof sudoers;
+    system: typeof system;
+    systemd: typeof systemd;
+    template: typeof template;
+    ufw: typeof ufw;
+    user: typeof user;
+};
+
+export { App, CHECKMARK, type ChgrpParams, type ChgrpResult, type ChmodParams, type ChmodResult, type ChownParams, type ChownResult, Cli, CommandResult, type EnvVarObj, type FileSystemOperations$1 as FileSystemOperations, Host, type IInvocation, type IRuntime, type InputMap, Invocation, LocalRuntime, type LogLevel, type ObjectType, type OsDetailsResult, type PkgInfoParams, type PkgInfoResult, type PkgInstallParams, type PkgInstallResult, type PkgIsInstalledParams, type PkgIsInstalledResult, type PkgRemoveParams, type PkgRemoveResult, type PkgUpdateParams, type PkgUpdateResult, type RebootIfNeededParams, type RebootIfNeededResult, type RebootNeededParams, type RebootNeededResult, type RebootParams, type RebootResult, RemoteRuntime, type RunFn, type RunFnReturnValue, SUDO_PROMPT_REGEX, type ShutdownParams, type ShutdownResult, Task, type TaskContext, type TaskFn, type TaskParams, type TaskPartialFn, Verbosity, XMARK, _default as core, task, withSudo };