@socketsecurity/lib 5.19.0 → 5.20.1

package/dist/http-request.d.ts

@@ -890,31 +890,6 @@ export declare function httpRequest(url: string, options?: HttpRequestOptions |
  * ```
  */
 export declare function httpText(url: string, options?: HttpRequestOptions | undefined): Promise<string>;
-/**
- * Parse a checksums file text into a filename-to-hash map.
- *
- * Supports standard checksums file formats:
- * - BSD style: "SHA256 (filename) = hash"
- * - GNU style: "hash  filename" (two spaces)
- * - Simple style: "hash filename" (single space)
- *
- * Lines starting with '#' are treated as comments and ignored.
- * Empty lines are ignored.
- *
- * @param text - Raw text content of a checksums file
- * @returns Map of filenames to lowercase SHA256 hashes
- *
- * @example
- * ```ts
- * const text = `
- * # SHA256 checksums
- * e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  file.zip
- * abc123def456...  other.tar.gz
- * `
- * const checksums = parseChecksums(text)
- * console.log(checksums['file.zip']) // 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
- * ```
- */
 export declare function parseChecksums(text: string): Checksums;
 /**
  * Parse a `Retry-After` HTTP header value into milliseconds.

package/dist/http-request.js

@@ -644,6 +644,9 @@ async function httpText(url, options) {
   }
   return response.text();
 }
+const CHECKSUM_BSD_RE = /^SHA256\s+\((.+)\)\s+=\s+([a-fA-F0-9]{64})$/;
+const CHECKSUM_GNU_RE = /^([a-fA-F0-9]{64})\s+(.+)$/;
+const RETRY_AFTER_INT_RE = /^\d+$/;
 function parseChecksums(text) {
   const checksums = { __proto__: null };
   for (const line of text.split("\n")) {
@@ -651,14 +654,12 @@ function parseChecksums(text) {
     if (!trimmed || trimmed.startsWith("#")) {
       continue;
     }
-    const bsdMatch = trimmed.match(
-      /^SHA256\s+\((.+)\)\s+=\s+([a-fA-F0-9]{64})$/
-    );
+    const bsdMatch = CHECKSUM_BSD_RE.exec(trimmed);
     if (bsdMatch) {
       checksums[bsdMatch[1]] = bsdMatch[2].toLowerCase();
       continue;
     }
-    const gnuMatch = trimmed.match(/^([a-fA-F0-9]{64})\s+(.+)$/);
+    const gnuMatch = CHECKSUM_GNU_RE.exec(trimmed);
     if (gnuMatch) {
       checksums[gnuMatch[2]] = gnuMatch[1].toLowerCase();
     }
@@ -674,7 +675,7 @@ function parseRetryAfterHeader(value) {
     return void 0;
   }
   const trimmed = raw.trim();
-  if (/^\d+$/.test(trimmed)) {
+  if (RETRY_AFTER_INT_RE.test(trimmed)) {
     const seconds = Number(trimmed);
     return seconds * 1e3;
   }

package/dist/ipc.js

@@ -35,15 +35,16 @@ __export(ipc_exports, {
 });
 module.exports = __toCommonJS(ipc_exports);
 var import_node_process = __toESM(require("node:process"));
+var import_typebox = require("./external/@sinclair/typebox");
 var import_socket = require("./paths/socket");
-var import_zod = require("./zod");
-const IpcStubSchema = import_zod.z.object({
+var import_validate_schema = require("./validation/validate-schema");
+const IpcStubSchema = import_typebox.Type.Object({
   /** Process ID that created the stub. */
-  pid: import_zod.z.number().int().positive(),
+  pid: import_typebox.Type.Integer({ minimum: 1 }),
   /** Creation timestamp for age validation. */
-  timestamp: import_zod.z.number().positive(),
+  timestamp: import_typebox.Type.Number({ exclusiveMinimum: 0 }),
   /** The actual data payload. */
-  data: import_zod.z.unknown()
+  data: import_typebox.Type.Unknown()
 });
 let _fs;
 let _path;
@@ -52,6 +53,24 @@ async function ensureIpcDirectory(filePath) {
   const path = /* @__PURE__ */ getPath();
   const dir = path.dirname(filePath);
   await fs.promises.mkdir(dir, { recursive: true, mode: 448 });
+  if (import_node_process.default.platform === "win32") {
+    return;
+  }
+  const stats = await fs.promises.lstat(dir);
+  if (!stats.isDirectory()) {
+    throw new Error(`IPC path is not a directory: ${dir}`);
+  }
+  const getuid = import_node_process.default.getuid;
+  const ownUid = typeof getuid === "function" ? getuid.call(import_node_process.default) : -1;
+  if (ownUid !== -1 && stats.uid !== ownUid) {
+    throw new Error(
+      `IPC directory ${dir} is owned by another user (uid ${stats.uid}); refusing to use it.`
+    );
+  }
+  const mode = stats.mode & 511;
+  if ((mode & 63) !== 0) {
+    await fs.promises.chmod(dir, 448);
+  }
 }
 // @__NO_SIDE_EFFECTS__
 function getFs() {
@@ -81,12 +100,26 @@ async function writeIpcStub(appName, data) {
     pid: import_node_process.default.pid,
     timestamp: Date.now()
   };
-  const validated = IpcStubSchema.parse(ipcData);
+  const validated = (0, import_validate_schema.parseSchema)(IpcStubSchema, ipcData);
   const fs = /* @__PURE__ */ getFs();
-  await fs.promises.writeFile(stubPath, JSON.stringify(validated, null, 2), {
-    encoding: "utf8",
-    mode: 384
-  });
+  const flags = fs.constants.O_CREAT | fs.constants.O_WRONLY | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW;
+  let handle;
+  try {
+    handle = await fs.promises.open(stubPath, flags, 384);
+  } catch (e) {
+    const err = e;
+    if (err.code === "EEXIST") {
+      await fs.promises.unlink(stubPath);
+      handle = await fs.promises.open(stubPath, flags, 384);
+    } else {
+      throw err;
+    }
+  }
+  try {
+    await handle.writeFile(JSON.stringify(validated, null, 2), "utf8");
+  } finally {
+    await handle.close();
+  }
   return stubPath;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/json/edit.d.ts

@@ -7,7 +7,7 @@ import type { EditableJsonConstructor } from './types';
  *
  * @example
  * ```ts
- * import { getEditableJsonClass } from '@socketsecurity/lib/json'
+ * import { getEditableJsonClass } from '@socketsecurity/lib/json/edit'
  *
  * const EditableJson = getEditableJsonClass<MyConfigType>()
  * const config = await EditableJson.load('./config.json')

package/dist/memoization.js

@@ -183,6 +183,11 @@ function memoizeAsync(fn, options = {}) {
       const inflight = refreshing.get(key);
       if (inflight) {
         (0, import_debug.debugLog)(`[memoizeAsync:${name}] stale-dedup`, { key });
+        const inflightIndex = accessOrder.indexOf(key);
+        if (inflightIndex !== -1) {
+          accessOrder.splice(inflightIndex, 1);
+        }
+        accessOrder.push(key);
         return await inflight;
       }
       cache.delete(key);
@@ -198,6 +203,7 @@ function memoizeAsync(fn, options = {}) {
         const entry = cache.get(key);
         if (entry) {
           entry.value = Promise.resolve(result);
+          entry.timestamp = Date.now();
         }
         return result;
       },

package/dist/paths/packages.js

@@ -34,8 +34,12 @@ function getPath() {
   return _path;
 }
 // @__NO_SIDE_EFFECTS__
+function isPackageJsonFile(filepath) {
+  return filepath === "package.json" || filepath.endsWith("/package.json") || filepath.endsWith("\\package.json");
+}
+// @__NO_SIDE_EFFECTS__
 function resolvePackageJsonDirname(filepath) {
-  if (filepath.endsWith("package.json")) {
+  if (/* @__PURE__ */ isPackageJsonFile(filepath)) {
     const path = /* @__PURE__ */ getPath();
     return (0, import_normalize.normalizePath)(path.dirname(filepath));
   }
@@ -43,7 +47,7 @@ function resolvePackageJsonDirname(filepath) {
 }
 // @__NO_SIDE_EFFECTS__
 function resolvePackageJsonPath(filepath) {
-  if (filepath.endsWith("package.json")) {
+  if (/* @__PURE__ */ isPackageJsonFile(filepath)) {
     return (0, import_normalize.normalizePath)(filepath);
   }
   const path = /* @__PURE__ */ getPath();

package/dist/promise-queue.js

@@ -69,7 +69,7 @@ class PromiseQueue {
       return;
     }
     this.running++;
-    task.fn().then(task.resolve).catch(task.reject).finally(() => {
+    Promise.resolve().then(() => task.fn()).then(task.resolve).catch(task.reject).finally(() => {
       this.running--;
       this.runNext();
     });

package/dist/stdio/clear.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview Terminal clearing and cursor utilities.
+ * Provides functions for clearing lines, screens, and managing cursor position.
+ */
+/**
+ * Clear the current line in the terminal.
+ * Uses native TTY methods when available, falls back to ANSI escape codes.
+ * Uses native TTY methods when available and falls back to `\r\x1b[K` ANSI
+ * escapes on non-TTY streams.
+ *
+ * ANSI Sequences:
+ * - `\r`: Carriage return (move to line start)
+ * - `\x1b[K`: Clear from cursor to end of line
+ *
+ * @param stream - Output stream to clear (defaults to `process.stdout`)
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * clearLine() // Clear current line on stdout
+ * clearLine(process.stderr) // Clear on stderr
+ * ```
+ */
+export declare function clearLine(stream?: NodeJS.WriteStream): void;
+/**
+ * Clear multiple lines above the current cursor position.
+ * Useful for clearing multi-line output like progress bars or status messages.
+ *
+ * ANSI Sequences:
+ * - `\x1b[1A`: Move cursor up one line
+ * - `\x1b[2K`: Erase entire line
+ *
+ * @param count - Number of lines to clear
+ * @param stream - Output stream to clear
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * console.log('Line 1')
+ * console.log('Line 2')
+ * console.log('Line 3')
+ * clearLines(2) // Clears lines 2 and 3
+ * ```
+ */
+export declare function clearLines(count: number, stream?: NodeJS.WriteStream): void;
+/**
+ * Clear the entire screen and reset cursor to top-left.
+ * Only works in TTY environments.
+ *
+ * ANSI Sequence:
+ * - `\x1bc`: Full reset (clear screen and move cursor home)
+ *
+ * @param stream - Output stream to clear
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * clearScreen() // Clear entire terminal
+ * ```
+ */
+export declare function clearScreen(stream?: NodeJS.WriteStream): void;
+/**
+ * Clear the visible terminal screen.
+ * Alias for `clearScreen()`.
+ *
+ * @param stream - Output stream to clear
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * clearVisible() // Same as clearScreen()
+ * ```
+ */
+export declare function clearVisible(stream?: NodeJS.WriteStream): void;
+/**
+ * Move cursor to the beginning of the current line.
+ * Uses native TTY methods when available, falls back to carriage return.
+ *
+ * @param stream - Output stream to manipulate
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * process.stdout.write('Some text...')
+ * cursorToStart()
+ * process.stdout.write('New text') // Overwrites from start
+ * ```
+ */
+export declare function cursorToStart(stream?: NodeJS.WriteStream): void;
+/**
+ * Hide the terminal cursor.
+ * Useful for cleaner output during animations or progress indicators.
+ *
+ * ANSI Sequence:
+ * - `\x1b[?25l`: DECTCEM hide cursor
+ *
+ * @param stream - Output stream to manipulate
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * hideCursor()
+ * // ... show animation
+ * showCursor()
+ * ```
+ */
+export declare function hideCursor(stream?: NodeJS.WriteStream): void;
+/**
+ * Restore cursor to previously saved position.
+ * Must be called after `saveCursor()`.
+ *
+ * ANSI Sequence:
+ * - `\x1b8`: DECRC restore cursor
+ *
+ * @param stream - Output stream to manipulate
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * saveCursor()
+ * console.log('Temporary text')
+ * restoreCursor()
+ * console.log('Back at saved position')
+ * ```
+ */
+export declare function restoreCursor(stream?: NodeJS.WriteStream): void;
+/**
+ * Save the current cursor position.
+ * Can be restored later with `restoreCursor()`.
+ *
+ * ANSI Sequence:
+ * - `\x1b7`: DECSC save cursor
+ *
+ * @param stream - Output stream to manipulate
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * saveCursor()
+ * console.log('Temporary text')
+ * restoreCursor()
+ * console.log('Back at saved position')
+ * ```
+ */
+export declare function saveCursor(stream?: NodeJS.WriteStream): void;
+/**
+ * Show the terminal cursor.
+ * Should be called after `hideCursor()` to restore normal cursor visibility.
+ *
+ * ANSI Sequence:
+ * - `\x1b[?25h`: DECTCEM show cursor
+ *
+ * @param stream - Output stream to manipulate
+ * @default stream process.stdout
+ *
+ * @example
+ * ```ts
+ * hideCursor()
+ * // ... show animation
+ * showCursor()
+ * ```
+ */
+export declare function showCursor(stream?: NodeJS.WriteStream): void;

package/dist/stdio/clear.js

@@ -0,0 +1,96 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clear_exports = {};
+__export(clear_exports, {
+  clearLine: () => clearLine,
+  clearLines: () => clearLines,
+  clearScreen: () => clearScreen,
+  clearVisible: () => clearVisible,
+  cursorToStart: () => cursorToStart,
+  hideCursor: () => hideCursor,
+  restoreCursor: () => restoreCursor,
+  saveCursor: () => saveCursor,
+  showCursor: () => showCursor
+});
+module.exports = __toCommonJS(clear_exports);
+var import_node_process = __toESM(require("node:process"));
+function clearLine(stream = import_node_process.default.stdout) {
+  if (stream.isTTY) {
+    stream.cursorTo(0);
+    stream.clearLine(0);
+  } else {
+    stream.write("\r\x1B[K");
+  }
+}
+function clearLines(count, stream = import_node_process.default.stdout) {
+  for (let i = 0; i < count; i++) {
+    stream.write("\x1B[1A\x1B[2K");
+  }
+}
+function clearScreen(stream = import_node_process.default.stdout) {
+  if (stream.isTTY) {
+    stream.write("\x1Bc");
+  }
+}
+function clearVisible(stream = import_node_process.default.stdout) {
+  clearScreen(stream);
+}
+function cursorToStart(stream = import_node_process.default.stdout) {
+  if (stream.isTTY) {
+    stream.cursorTo(0);
+  } else {
+    stream.write("\r");
+  }
+}
+function hideCursor(stream = import_node_process.default.stdout) {
+  stream.write("\x1B[?25l");
+}
+function restoreCursor(stream = import_node_process.default.stdout) {
+  stream.write("\x1B8");
+}
+function saveCursor(stream = import_node_process.default.stdout) {
+  stream.write("\x1B7");
+}
+function showCursor(stream = import_node_process.default.stdout) {
+  stream.write("\x1B[?25h");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearLine,
+  clearLines,
+  clearScreen,
+  clearVisible,
+  cursorToStart,
+  hideCursor,
+  restoreCursor,
+  saveCursor,
+  showCursor
+});

package/dist/stdio/progress.d.ts

@@ -0,0 +1,152 @@
+/**
+ * @fileoverview Progress bar utilities for CLI applications.
+ * Provides various progress indicators including bars, percentages, and spinners.
+ */
+export interface ProgressBarOptions {
+    /**
+     * Width of the progress bar in characters.
+     * @default 40
+     */
+    width?: number | undefined;
+    /**
+     * Format template for progress bar display.
+     * Available tokens: `:bar`, `:percent`, `:current`, `:total`, `:elapsed`, `:eta`.
+     * Custom tokens can be passed via the `tokens` parameter in `update()` or `tick()`.
+     * @default ':bar :percent :current/:total'
+     * @example
+     * ```ts
+     * format: ':bar :percent :current/:total :eta'
+     * ```
+     */
+    format?: string | undefined;
+    /**
+     * Character(s) to use for completed portion of bar.
+     * @default '█'
+     */
+    complete?: string | undefined;
+    /**
+     * Character(s) to use for incomplete portion of bar.
+     * @default '░'
+     */
+    incomplete?: string | undefined;
+    /**
+     * Character(s) to use for the head of the progress bar.
+     * @default ''
+     */
+    head?: string | undefined;
+    /**
+     * Clear the progress bar when complete.
+     * @default false
+     */
+    clear?: boolean | undefined;
+    /**
+     * Minimum time between renders in milliseconds.
+     * ~60fps = 16ms throttle.
+     * @default 16
+     */
+    renderThrottle?: number | undefined;
+    /**
+     * Stream to write progress bar output to.
+     * @default process.stderr
+     */
+    stream?: NodeJS.WriteStream | undefined;
+    /**
+     * Color to apply to the completed portion of the bar.
+     * @default 'cyan'
+     */
+    color?: 'cyan' | 'green' | 'yellow' | 'blue' | 'magenta' | undefined;
+}
+export declare class ProgressBar {
+    private current;
+    private total;
+    private startTime;
+    private lastRender;
+    private stream;
+    private options;
+    private terminated;
+    private lastDrawnWidth;
+    /**
+     * Create a new progress bar instance.
+     *
+     * @param total - Total number of units for the progress bar
+     * @param options - Configuration options for the progress bar
+     *
+     * @example
+     * ```ts
+     * const bar = new ProgressBar(100, {
+     *   width: 50,
+     *   format: ':bar :percent :current/:total :eta',
+     *   color: 'green'
+     * })
+     * ```
+     */
+    constructor(total: number, options?: ProgressBarOptions);
+    /**
+     * Update progress to a specific value and redraw the bar.
+     * Updates are throttled to prevent excessive rendering (default ~60fps).
+     *
+     * @param current - Current progress value (will be clamped to total)
+     * @param tokens - Optional custom tokens to replace in format string
+     *
+     * @example
+     * ```ts
+     * bar.update(50)
+     * bar.update(75, { status: 'Processing...' })
+     * ```
+     */
+    update(current: number, tokens?: Record<string, unknown>): void;
+    /**
+     * Increment progress by a specified amount.
+     * Convenience method for `update(current + amount)`.
+     *
+     * @param amount - Amount to increment by
+     * @param tokens - Optional custom tokens to replace in format string
+     * @default amount 1
+     *
+     * @example
+     * ```ts
+     * bar.tick() // Increment by 1
+     * bar.tick(5) // Increment by 5
+     * bar.tick(1, { file: 'data.json' })
+     * ```
+     */
+    tick(amount?: number, tokens?: Record<string, unknown>): void;
+    /**
+     * Render the progress bar.
+     */
+    private render;
+    /**
+     * Clear the current line.
+     */
+    private clearLine;
+    /**
+     * Format time in seconds to human readable.
+     */
+    private formatTime;
+    /**
+     * Terminate the progress bar and optionally clear it.
+     * Called automatically when progress reaches 100%.
+     * If `clear` option is true, removes the bar from terminal.
+     * Otherwise, moves to next line to preserve the final state.
+     */
+    terminate(): void;
+}
+/**
+ * Create a simple progress indicator without a graphical bar.
+ * Returns a formatted string showing progress as percentage and fraction.
+ *
+ * @param current - Current progress value
+ * @param total - Total progress value
+ * @param label - Optional label prefix
+ * @returns Formatted progress indicator string
+ *
+ * @example
+ * ```ts
+ * createProgressIndicator(50, 100)
+ * // Returns: '[50%] 50/100'
+ *
+ * createProgressIndicator(3, 10, 'Files')
+ * // Returns: 'Files: [30%] 3/10'
+ * ```
+ */
+export declare function createProgressIndicator(current: number, total: number, label?: string | undefined): string;