@kikiutils/shared 18.3.0 → 20.0.0

package/src/logger/node/index.ts

@@ -0,0 +1,173 @@
+import { writeSync } from 'node:fs';
+import { stripVTControlCharacters } from 'node:util';
+
+import { supportsLoggerColor } from '../_internals/formatter';
+import { getLoggerStreamName } from '../_internals/levels';
+import {
+    createDiagnosticReporter,
+    createLoggerCore,
+} from '../_internals/logger';
+import type { LoggerDiagnostic } from '../types';
+
+import { createFileWriter } from './_internals/file-writer';
+import { formatNodeLoggerRecord } from './_internals/formatter';
+import type {
+    NodeLogger,
+    NodeLoggerOptions,
+} from './types';
+
+interface ConsoleStreamState {
+    onClose: () => void;
+    onError: (error: Error) => void;
+    owners: Set<object>;
+    pending: Set<(error?: Error | null) => void>;
+}
+
+// Constants/Variables
+const consoleStreams = new WeakMap<NodeJS.WriteStream, ConsoleStreamState>();
+
+// Functions
+
+/**
+ * Creates a Node.js/Bun logger with optional bounded, append-only file output and rotation.
+ *
+ * Log calls never throw or reject. Awaiting them waits for processing, not proof of successful
+ * persistence: overload drops the newest file record and failures are reported safely. Factory
+ * validation/open failures reject. Call close explicitly; no process signal handlers are installed.
+ */
+export async function createNodeLogger(options: NodeLoggerOptions = {}): Promise<Readonly<NodeLogger>> {
+    const report = createDiagnosticReporter(options.onError, (message) => writeSync(2, message));
+    let writer: Awaited<ReturnType<typeof createFileWriter>> | undefined;
+    let closed = false;
+    let closePromise: Promise<void> | undefined;
+    const consoleOwner = {};
+    const consoleTargets = new Set<NodeJS.WriteStream>();
+    const consoleWrites = new Set<Promise<void>>();
+    const logger = createLoggerCore(
+        options,
+        {
+            report,
+            write(record) {
+                if (closed) {
+                    report({
+                        message: 'Logger is closed.',
+                        type: 'closed',
+                    });
+
+                    return;
+                }
+
+                if (!record.console && !writer) return;
+                const target = process[getLoggerStreamName(record.type)];
+
+                const text = formatNodeLoggerRecord(record, record.console && supportsLoggerColor(target));
+                if (record.console) {
+                    const line = `${text}\n`;
+                    consoleTargets.add(target);
+                    const completion = writeConsole(target, line, report, consoleOwner);
+                    consoleWrites.add(completion);
+                    void completion.then(() => consoleWrites.delete(completion));
+                    const fileCompletion = writer?.write(`${stripVTControlCharacters(text)}\n`);
+                    return fileCompletion
+                        ? Promise.all([
+                            completion,
+                            fileCompletion,
+                        ]).then(() => {})
+                        : completion;
+                }
+
+                return writer?.write(`${stripVTControlCharacters(text)}\n`);
+            },
+        },
+    );
+
+    if (options.file !== undefined && options.file !== false) writer = await createFileWriter(options.file, report);
+
+    return Object.freeze({
+        ...logger,
+        close() {
+            if (closePromise) return closePromise;
+            closed = true;
+            closePromise = (async () => {
+                await Promise.all([
+                    writer?.close(),
+                    ...consoleWrites,
+                ]);
+
+                for (const target of consoleTargets) {
+                    const state = consoleStreams.get(target);
+                    if (!state) continue;
+                    state.owners.delete(consoleOwner);
+                    if (!state.owners.size) {
+                        target.off('error', state.onError);
+                        target.off('close', state.onClose);
+                        consoleStreams.delete(target);
+                    }
+                }
+
+                consoleTargets.clear();
+            })();
+            return closePromise;
+        },
+        getStats: () => writer?.getStats() ?? Object.freeze({
+            droppedCount: 0,
+            pendingBytes: 0,
+            writeErrorCount: 0,
+        }),
+    });
+}
+
+/** One error listener per shared output stream; retained until its last owning logger calls close(). */
+function writeConsole(
+    target: NodeJS.WriteStream,
+    text: string,
+    report: (event: LoggerDiagnostic) => void,
+    owner: object,
+) {
+    let state = consoleStreams.get(target);
+    if (!state) {
+        const pending = new Set<(error?: Error | null) => void>();
+        const onError = (error: Error) => {
+            for (const settle of pending) settle(error);
+        };
+
+        const onClose = () => onError(new Error('Console stream closed.'));
+        state = {
+            onClose,
+            onError,
+            owners: new Set(),
+            pending,
+        };
+
+        consoleStreams.set(target, state);
+        target.on('error', onError);
+        target.on('close', onClose);
+    }
+
+    state.owners.add(owner);
+    const current = state;
+    return new Promise<void>((resolveWritten) => {
+        let settled = false;
+        const settle = (error?: Error | null) => {
+            if (settled) return;
+            settled = true;
+            current.pending.delete(settle);
+            if (error) {
+                report({
+                    error,
+                    message: 'Console output failed.',
+                    type: 'console',
+                });
+            }
+
+            resolveWritten();
+        };
+
+        current.pending.add(settle);
+        try {
+            target.write(text, settle);
+        } catch (error) {
+            settle(error instanceof Error ? error : new Error('Console output failed.'));
+        }
+    });
+}

package/src/logger/node/types.ts

@@ -0,0 +1,58 @@
+import type { PathLike } from '../../classes/path';
+import type {
+    Logger,
+    LoggerOptions,
+} from '../types';
+
+/** Specify interval and/or maxSize. Size limits use positive integers with B, K, M, or G (binary units). */
+export type LoggerRotationOptions = {
+    /** Gzip historical files. Defaults to true. */
+    compress?: boolean;
+
+    /** Number of historical files, excluding the active file. Defaults to 30. */
+    keepFiles?: number;
+
+    /** Maximum combined size of historical files. */
+    maxTotalSize?: string;
+} & (
+  | {
+      /** Opt-in time rotation aligned to the system's local calendar boundary. */
+      interval: 'daily' | 'hourly';
+      maxSize?: string;
+  }
+  | {
+      /** Opt-in time rotation aligned to the system's local calendar boundary. */
+      interval?: 'daily' | 'hourly';
+      maxSize: string;
+  }
+);
+
+export interface LoggerFileOptions {
+    /** Maximum unfinished payload bytes, including data already submitted to the stream. */
+    maxPendingBytes?: number;
+
+    /** Resolved once at creation. The file is opened in append mode. */
+    path: PathLike;
+
+    /** Omitted or false disables rotation. An object must specify interval or maxSize. */
+    rotate?: false | LoggerRotationOptions;
+}
+
+export interface NodeLogger extends Logger {
+    /** Stop accepting records, finish accepted file writes, then release the stream. Not fsync. */
+    close: () => Promise<void>;
+
+    /** A fresh, frozen file-output snapshot. Dropped/failed records still resolve their logging promises. */
+    getStats: () => Readonly<NodeLoggerStats>;
+}
+
+export interface NodeLoggerOptions extends LoggerOptions {
+    /** Disabled by default. Each logger owns at most one fixed file destination. */
+    file?: false | LoggerFileOptions;
+}
+
+export interface NodeLoggerStats {
+    droppedCount: number;
+    pendingBytes: number;
+    writeErrorCount: number;
+}

package/src/logger/types.ts

@@ -0,0 +1,60 @@
+/** Minimum severity to emit; `success` uses the same threshold as `info`. */
+export type LoggerLevel = 'debug' | 'error' | 'fatal' | 'info' | 'silent' | 'trace' | 'warn';
+
+/** A logging method, including the informational success presentation. */
+export type LoggerMethod = 'success' | Exclude<LoggerLevel, 'silent'>;
+
+/**
+ * A logger whose logging methods never throw or reject for recoverable failures.
+ *
+ * Awaiting a method waits for processing, not guaranteed successful delivery or fsync.
+ * Configuration errors may throw from the factory, configure(), or setLevel().
+ * Factories freeze the API object; settings remain adjustable through its methods.
+ */
+export interface Logger {
+    configure: (options: Pick<LoggerOptions, 'console' | 'icons' | 'prefix' | 'suffix' | 'timestamp'>) => void;
+    debug: (...args: unknown[]) => Promise<void>;
+    error: (...args: unknown[]) => Promise<void>;
+    fatal: (...args: unknown[]) => Promise<void>;
+    info: (...args: unknown[]) => Promise<void>;
+
+    /** Accepts success as an informational method; it is not a configurable threshold. */
+    isLevelEnabled: (level: LoggerLevel | LoggerMethod) => boolean;
+
+    /** Sets a severity threshold (not success); env restores environment-driven filtering. */
+    setLevel: (level: 'env' | LoggerLevel) => void;
+    success: (...args: unknown[]) => Promise<void>;
+    trace: (...args: unknown[]) => Promise<void>;
+    warn: (...args: unknown[]) => Promise<void>;
+}
+
+/** A shallow-frozen failure notification; nested error values retain their original ownership. */
+export interface LoggerDiagnostic {
+    droppedCount?: number;
+    error?: unknown;
+    message: string;
+
+    /** Same-type notifications suppressed since the previous emitted diagnostic. */
+    suppressedCount?: number;
+    type: 'closed' | 'console' | 'file' | 'format' | 'invalid-level' | 'overflow';
+}
+
+/** Configuration shared by browser and server loggers. */
+export interface LoggerOptions {
+    /** Enables console output. Defaults to `true`. */
+    console?: boolean;
+
+    /** Enables Unicode level icons. Defaults to `true`. */
+    icons?: boolean;
+
+    /** Overrides LOG_LEVEL; `env` restores the environment-driven threshold. */
+    level?: 'env' | LoggerLevel;
+
+    /** Best-effort, rate-limited notification; failures in this callback are contained. */
+    onError?: (event: Readonly<LoggerDiagnostic>) => void;
+    prefix?: string;
+    suffix?: string;
+
+    /** Enables the fixed local-time millisecond prefix. Defaults to `true`. */
+    timestamp?: boolean;
+}

package/src/storages/redis/keyed-store.ts

@@ -8,7 +8,7 @@ import type { RedisLikeStorage } from './types';
  * @remarks
  * The key resolver is called synchronously once per operation with the operation's key arguments.
  * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.
- * `setItemWithTtl` accepts its TTL in seconds before the value and key arguments.
+ * `setItemWithTtl` and `setItemWithTtlIfAbsent` accept their TTL in seconds before the value and key arguments.
  * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.
  *
  * @typeParam D - The stored value type used by reads and writes.
@@ -16,10 +16,11 @@ import type { RedisLikeStorage } from './types';
  * @param storage - The shared Redis-like storage instance.
  *
  * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.
- * Reads, writes, removals, and TTL results retain the underlying storage contract.
+ * Reads, atomic read-and-removals, writes, removals, and TTL results retain the underlying storage contract.
  */
 export function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {
     return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({
+        getAndRemoveItem: (...args: P) => storage.getAndRemoveItem<D>(keyFn(...args)),
         getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),
         getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),
         hasItem: (...args: P) => storage.hasItem(keyFn(...args)),
@@ -29,5 +30,8 @@ export function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisL
         setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {
             return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);
         },
+        setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P) {
+            return storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);
+        },
     });
 }

package/src/storages/redis/msgpack.ts

@@ -18,7 +18,8 @@ if (!isNativeAccelerationEnabled) {
  *
  * @remarks
  * Adapter rejections and MessagePack serialization errors propagate to the caller.
- * Reads resolve to `null` when no raw value exists. Writes resolve to `true` only when the adapter returns `OK`;
+ * Reads resolve to `null` when no raw value exists; `getAndRemoveItem` reads and deletes in one atomic adapter call.
+ * Writes resolve to `true` only when the adapter returns `OK`;
  * removal resolves to `true` only when exactly one key is deleted.
  * The adapter remains caller-owned; creating the facade does not open or close a connection.
  *
@@ -37,6 +38,11 @@ if (!isNativeAccelerationEnabled) {
  * const adapter: RedisLikeAdapter = {
  *     delete: async (key) => values.delete(key) ? 1 : 0,
  *     getBuffer: async (key) => values.get(key) ?? null,
+ *     getBufferAndDelete: async (key) => {
+ *         const value = values.get(key) ?? null;
+ *         values.delete(key);
+ *         return value;
+ *     },
  *     has: async (key) => values.has(key),
  *     setBuffer: async (key, value) => {
  *         values.set(key, value);
@@ -45,6 +51,9 @@ if (!isNativeAccelerationEnabled) {
  *     setBufferEx: async () => {
  *         throw new Error('TTL writes are not supported by this example adapter');
  *     },
+ *     setBufferExNx: async () => {
+ *         throw new Error('TTL writes are not supported by this example adapter');
+ *     },
  *     ttl: async (key) => values.has(key) ? -1 : -2,
  * };
  *
@@ -56,6 +65,10 @@ if (!isNativeAccelerationEnabled) {
  */
 export function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage> {
     return Object.freeze({
+        async getAndRemoveItem<T = unknown>(key: string) {
+            const rawValue = await adapter.getBufferAndDelete(key);
+            return rawValue ? decode(rawValue) as T : null;
+        },
         async getItem<T = unknown>(key: string) {
             const rawValue = await adapter.getBuffer(key);
             return rawValue ? decode(rawValue) as T : null;
@@ -67,5 +80,8 @@ export function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<R
         async setItemWithTtl(key: string, ttlSeconds: number, value: any) {
             return await adapter.setBufferEx(key, ttlSeconds, encode(value)) === 'OK';
         },
+        async setItemWithTtlIfAbsent(key: string, ttlSeconds: number, value: any) {
+            return await adapter.setBufferExNx(key, ttlSeconds, encode(value)) === 'OK';
+        },
     });
 }

package/src/storages/redis/types.ts

@@ -16,6 +16,12 @@ export interface RedisLikeAdapter {
      */
     getBuffer: (key: string) => Promise<null | Uint8Array>;
 
+    /**
+     * Atomically reads and deletes a key, such as with Redis `GETDEL`,
+     * and resolves to its raw bytes, or `null` when the key is missing.
+     */
+    getBufferAndDelete: (key: string) => Promise<null | Uint8Array>;
+
     /**
      * Checks a key and resolves to whether it exists.
      */
@@ -35,6 +41,16 @@ export interface RedisLikeAdapter {
      */
     setBufferEx: (key: string, ttlSeconds: number, value: Uint8Array) => Promise<'OK' | void>;
 
+    /**
+     * Writes raw bytes with an expiry only when the key is missing, such as with Redis `SET key value EX ttl NX`,
+     * and resolves to the backend acknowledgment, or `null` or no value when the key already exists.
+     *
+     * @param key - The storage key.
+     * @param ttlSeconds - The expiry duration in seconds.
+     * @param value - The raw bytes to store.
+     */
+    setBufferExNx: (key: string, ttlSeconds: number, value: Uint8Array) => Promise<'OK' | null | void>;
+
     /**
      * Reads a key's remaining TTL in seconds, or `-1` for no expiry and `-2` for a missing key.
      */
@@ -49,6 +65,14 @@ export interface RedisLikeAdapter {
  * `-1` means no expiry, and `-2` means the key is missing. Connection cleanup remains caller-owned.
  */
 export interface RedisLikeStorage {
+    /**
+     * Atomically reads and removes a deserialized value and resolves to `null` when the key is missing.
+     * Concurrent callers on the same key receive the value at most once.
+     *
+     * @typeParam T - The expected value type; deserialization does not validate this type.
+     */
+    getAndRemoveItem: <T = unknown>(key: string) => Promise<null | T>;
+
     /**
      * Reads a deserialized value and resolves to `null` when the key is missing.
      *
@@ -84,4 +108,14 @@ export interface RedisLikeStorage {
      * @param value - The value to serialize and store.
      */
     setItemWithTtl: (key: string, ttlSeconds: number, value: any) => Promise<boolean>;
+
+    /**
+     * Atomically stores a value with an expiry only when the key is missing
+     * and resolves to whether the backend acknowledges the write.
+     *
+     * @param key - The storage key.
+     * @param ttlSeconds - The expiry duration in seconds.
+     * @param value - The value to serialize and store.
+     */
+    setItemWithTtlIfAbsent: (key: string, ttlSeconds: number, value: any) => Promise<boolean>;
 }

package/src/types/index.ts

@@ -6,11 +6,6 @@ import type {
 
 export type { FilteredKeyPath } from './filtered-key-path';
 
-/**
- * A generic string-keyed object for utility APIs that intentionally accept any value shape.
- */
-export type AnyRecord = Record<string, any>;
-
 /**
  * Binary-like inputs accepted by `toBuffer` across browser and Node.js runtimes.
  */
@@ -31,11 +26,6 @@ export type MaybePartial<T> = Partial<T> | T;
  */
 export type MaybeReadonly<T> = Readonly<T> | T;
 
-/**
- * Number-like value represented as a number or a numeric string.
- */
-export type Numberish = number | string;
-
 /**
  * A `Record` where every key is optional.
  */

package/dist/classes/ssh-client.d.ts

@@ -1,40 +0,0 @@
-import { PathLike } from "./path.js";
-import { Config, NodeSSH, SSHExecCommandOptions, SSHGetPutDirectoryOptions, SSHPutFilesOptions } from "node-ssh";
-import { SFTPWrapper, TransferOptions } from "ssh2";
-//#region src/classes/ssh-client.d.ts
-declare const loggerLevelStringToConsolaLogLevelMap: {
-  readonly debug: 4;
-  readonly error: 0;
-  readonly fatal: 0;
-  readonly info: 3;
-  readonly normal: 2;
-  readonly silent: -999;
-  readonly trace: 5;
-  readonly verbose: 999;
-  readonly warn: 1;
-};
-export declare class SshClient {
-  #private;
-  getDir: (localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) => Promise<boolean>;
-  putDir: (localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) => Promise<boolean>;
-  constructor(host: string, username: string, password: string, port?: number, connectConfig?: Config);
-  get nodeSsh(): NodeSSH;
-  connect(): Promise<boolean>;
-  disconnect(): boolean;
-  execCommand(command: string, options?: SSHExecCommandOptions): Promise<void | import("node-ssh").SSHExecCommandResponse>;
-  execCommandWithIo(command: string, options?: SSHExecCommandOptions): Promise<void | import("node-ssh").SSHExecCommandResponse>;
-  getDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions): Promise<boolean>;
-  getFile(localFile: PathLike, remoteFile: PathLike, givenSftp?: null | SFTPWrapper, transferOptions?: null | TransferOptions): Promise<boolean>;
-  isConnected(): boolean;
-  mkdir(path: PathLike): Promise<boolean>;
-  putDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions): Promise<boolean>;
-  putFile(localFile: PathLike, remoteFile: PathLike, givenSftp?: null | SFTPWrapper, transferOptions?: null | TransferOptions): Promise<boolean>;
-  putFiles(files: {
-    local: PathLike;
-    remote: PathLike;
-  }[], options?: SSHPutFilesOptions): Promise<boolean>;
-  setLoggerLevel(level: keyof typeof loggerLevelStringToConsolaLogLevelMap): void;
-}
-//#endregion
-export {};
-//# sourceMappingURL=ssh-client.d.ts.map

package/dist/classes/ssh-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssh-client.d.ts","names":[],"sources":["../../src/classes/ssh-client.ts"],"mappings":";;;;cAgBM;;;;;;;;;;;qBAYO;;EAOT,SAAM,gBA2D6B,UAAQ,iBAAmB,UAAQ,UAAY,8BAAyB;EA1D3G,SAAM,gBAgG6B,UAAQ,iBAAmB,UAAQ,UAAY,8BAAyB;EA7F/F,YAAA,cAAc,kBAAkB,kBAAkB,eAAmB,gBAAgB;MAe7F,WAAO;EAKL,WAAO;EAUb;EAUA,YAAY,iBAAiB,UAAU,wBAAqB,kCAAA;EAI5D,kBAAkB,iBAAiB,UAAU,wBAAqB,kCAAA;EAW5D,aAAa,gBAAgB,UAAU,iBAAiB,UAAU,UAAU,4BAAyB;EASrG,QACF,WAAW,UACX,YAAY,UACZ,mBAAmB,aACnB,yBAAyB,kBAAe;EAW5C;EAIM,MAAM,MAAM,WAAQ;EAUpB,aAAa,gBAAgB,UAAU,iBAAiB,UAAU,UAAU,4BAAyB;EASrG,QACF,WAAW,UACX,YAAY,UACZ,mBAAmB,aACnB,yBAAyB,kBAAe;EAWtC,SAAS;IAAS,OAAO;IAAU,QAAQ;OAAc,UAAU,qBAAkB;EAe3F,eAAe,oBAAoB"}

package/dist/classes/ssh-client.js

@@ -1,130 +0,0 @@
-import { createConsola } from "consola";
-import { NodeSSH } from "node-ssh";
-//#region src/classes/ssh-client.ts
-const loggerLevelStringToConsolaLogLevelMap = {
-	debug: 4,
-	error: 0,
-	fatal: 0,
-	info: 3,
-	normal: 2,
-	silent: -999,
-	trace: 5,
-	verbose: 999,
-	warn: 1
-};
-var SshClient = class {
-	#connectConfig;
-	#logger;
-	#nodeSsh;
-	getDir = this.getDirectory;
-	putDir = this.putDirectory;
-	constructor(host, username, password, port = 22, connectConfig) {
-		this.#connectConfig = {
-			...connectConfig,
-			host,
-			password,
-			port,
-			username
-		};
-		this.#logger = createConsola();
-		this.#nodeSsh = new NodeSSH();
-		if (process.env.NODE_ENV === "production") this.setLoggerLevel("error");
-	}
-	get nodeSsh() {
-		return this.#nodeSsh;
-	}
-	async connect() {
-		try {
-			this.#nodeSsh = await this.#nodeSsh.connect(this.#connectConfig);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	disconnect() {
-		try {
-			this.#nodeSsh.dispose();
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	execCommand(command, options) {
-		return this.#nodeSsh.execCommand(command, options).catch(() => {});
-	}
-	execCommandWithIo(command, options) {
-		return this.execCommand(command, {
-			...options,
-			onStderr: (data) => process.stderr.write(data.toString()),
-			onStdout: (data) => process.stdout.write(data.toString())
-		});
-	}
-	async getDirectory(localDirectory, remoteDirectory, options) {
-		try {
-			return await this.#nodeSsh.getDirectory(localDirectory.toString(), remoteDirectory.toString(), options);
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async getFile(localFile, remoteFile, givenSftp, transferOptions) {
-		try {
-			await this.#nodeSsh.getFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	isConnected() {
-		return this.#nodeSsh.isConnected();
-	}
-	async mkdir(path) {
-		try {
-			await this.#nodeSsh.mkdir(path.toString());
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async putDirectory(localDirectory, remoteDirectory, options) {
-		try {
-			return await this.#nodeSsh.putDirectory(localDirectory.toString(), remoteDirectory.toString(), options);
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async putFile(localFile, remoteFile, givenSftp, transferOptions) {
-		try {
-			await this.#nodeSsh.putFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	async putFiles(files, options) {
-		try {
-			const convertedFiles = files.map(({ local, remote }) => ({
-				local: local.toString(),
-				remote: remote.toString()
-			}));
-			await this.#nodeSsh.putFiles(convertedFiles, options);
-			return true;
-		} catch (error) {
-			this.#logger.error(error);
-			return false;
-		}
-	}
-	setLoggerLevel(level) {
-		this.#logger.level = loggerLevelStringToConsolaLogLevelMap[level];
-	}
-};
-//#endregion
-export { SshClient };
-
-//# sourceMappingURL=ssh-client.js.map

package/dist/classes/ssh-client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssh-client.js","names":[],"sources":["../../src/classes/ssh-client.ts"],"sourcesContent":["import { createConsola } from 'consola';\nimport type { ConsolaInstance } from 'consola';\nimport { NodeSSH } from 'node-ssh';\nimport type {\n    Config,\n    SSHExecCommandOptions,\n    SSHGetPutDirectoryOptions,\n    SSHPutFilesOptions,\n} from 'node-ssh';\nimport type {\n    SFTPWrapper,\n    TransferOptions,\n} from 'ssh2';\n\nimport type { PathLike } from './path';\n\nconst loggerLevelStringToConsolaLogLevelMap = {\n    debug: 4,\n    error: 0,\n    fatal: 0,\n    info: 3,\n    normal: 2,\n    silent: -999,\n    trace: 5,\n    verbose: 999,\n    warn: 1,\n} as const;\n\nexport class SshClient {\n    // Private instance properties\n    readonly #connectConfig: Config;\n    readonly #logger: ConsolaInstance;\n    #nodeSsh: NodeSSH;\n\n    // Public instance properties\n    getDir = this.getDirectory;\n    putDir = this.putDirectory;\n\n    // Constructor\n    constructor(host: string, username: string, password: string, port: number = 22, connectConfig?: Config) {\n        this.#connectConfig = {\n            ...connectConfig,\n            host,\n            password,\n            port,\n            username,\n        };\n\n        this.#logger = createConsola();\n        this.#nodeSsh = new NodeSSH();\n        if (process.env.NODE_ENV === 'production') this.setLoggerLevel('error');\n    }\n\n    // Public instance accessors\n    get nodeSsh() {\n        return this.#nodeSsh;\n    }\n\n    // Public instance methods\n    async connect() {\n        try {\n            this.#nodeSsh = await this.#nodeSsh.connect(this.#connectConfig);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    disconnect() {\n        try {\n            this.#nodeSsh.dispose();\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    execCommand(command: string, options?: SSHExecCommandOptions) {\n        return this.#nodeSsh.execCommand(command, options).catch(() => {});\n    }\n\n    execCommandWithIo(command: string, options?: SSHExecCommandOptions) {\n        return this.execCommand(\n            command,\n            {\n                ...options,\n                onStderr: (data) => process.stderr.write(data.toString()),\n                onStdout: (data) => process.stdout.write(data.toString()),\n            },\n        );\n    }\n\n    async getDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) {\n        try {\n            return await this.#nodeSsh.getDirectory(localDirectory.toString(), remoteDirectory.toString(), options);\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async getFile(\n        localFile: PathLike,\n        remoteFile: PathLike,\n        givenSftp?: null | SFTPWrapper,\n        transferOptions?: null | TransferOptions,\n    ) {\n        try {\n            await this.#nodeSsh.getFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    isConnected() {\n        return this.#nodeSsh.isConnected();\n    }\n\n    async mkdir(path: PathLike) {\n        try {\n            await this.#nodeSsh.mkdir(path.toString());\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async putDirectory(localDirectory: PathLike, remoteDirectory: PathLike, options?: SSHGetPutDirectoryOptions) {\n        try {\n            return await this.#nodeSsh.putDirectory(localDirectory.toString(), remoteDirectory.toString(), options);\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async putFile(\n        localFile: PathLike,\n        remoteFile: PathLike,\n        givenSftp?: null | SFTPWrapper,\n        transferOptions?: null | TransferOptions,\n    ) {\n        try {\n            await this.#nodeSsh.putFile(localFile.toString(), remoteFile.toString(), givenSftp, transferOptions);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    async putFiles(files: { local: PathLike; remote: PathLike }[], options?: SSHPutFilesOptions) {\n        try {\n            const convertedFiles = files.map(({ local, remote }) => ({\n                local: local.toString(),\n                remote: remote.toString(),\n            }));\n\n            await this.#nodeSsh.putFiles(convertedFiles, options);\n            return true;\n        } catch (error) {\n            this.#logger.error(error);\n            return false;\n        }\n    }\n\n    setLoggerLevel(level: keyof typeof loggerLevelStringToConsolaLogLevelMap) {\n        this.#logger.level = loggerLevelStringToConsolaLogLevelMap[level];\n    }\n}\n"],"mappings":"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"}

package/dist/consola.d.ts

@@ -1,24 +0,0 @@
-//#region src/consola.d.ts
-/**
- * A consola logger with environment-controlled verbosity.
- *
- * @remarks
- * `CONSOLA_LOGGER_LEVEL` sets the log level when defined at module initialization;
- * otherwise, `NODE_ENV=production` selects `0`, and other environments retain the logger's default level.
- * Assign `logger.level` to change verbosity after initialization.
- *
- * @example
- *
- * ```ts
- * import { logger } from '@kikiutils/shared/consola';
- *
- * logger.level = 3;
- * logger.info('Application started');
- * ```
- *
- * @see {@link https://github.com/unjs/consola#log-level | Consola log levels}
- */
-export declare const consolaLogger: import("consola").ConsolaInstance;
-export declare const logger: import("consola").ConsolaInstance;
-//#endregion
-//# sourceMappingURL=consola.d.ts.map

package/dist/consola.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consola.d.ts","names":[],"sources":["../src/consola.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAqBa,iCAAa;qBACb,0BAAM"}