@socketsecurity/lib 3.0.2 → 3.0.3

package/dist/ipc.js

@@ -1,3 +1,246 @@
 /* Socket Lib - Built with esbuild */
-var P=Object.create;var m=Object.defineProperty;var N=Object.getOwnPropertyDescriptor;var B=Object.getOwnPropertyNames;var O=Object.getPrototypeOf,A=Object.prototype.hasOwnProperty;var J=(t,e)=>{for(var n in e)m(t,n,{get:e[n],enumerable:!0})},y=(t,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of B(e))!A.call(t,s)&&s!==n&&m(t,s,{get:()=>e[s],enumerable:!(o=N(e,s))||o.enumerable});return t};var k=(t,e,n)=>(n=t!=null?P(O(t)):{},y(e||!t||!t.__esModule?m(n,"default",{value:t,enumerable:!0}):n,t)),$=t=>y(m({},"__esModule",{value:!0}),t);var L={};J(L,{IpcHandshakeSchema:()=>E,cleanupIpcStubs:()=>z,createIpcChannelId:()=>F,createIpcMessage:()=>G,getIpcStubPath:()=>x,hasIpcChannel:()=>K,onIpc:()=>S,parseIpcMessage:()=>v,readIpcStub:()=>W,sendIpc:()=>_,waitForIpc:()=>q,writeIpcStub:()=>H});module.exports=$(L);var l=k(require("crypto")),c=require("fs"),p=k(require("path")),g=require("./fs"),h=require("./paths"),i=require("./zod");const w=i.z.object({id:i.z.string().min(1),timestamp:i.z.number().positive(),type:i.z.string().min(1),data:i.z.unknown()}),E=w.extend({type:i.z.literal("handshake"),data:i.z.object({version:i.z.string(),pid:i.z.number().int().positive(),apiToken:i.z.string().optional(),appName:i.z.string()})}),I=i.z.object({pid:i.z.number().int().positive(),timestamp:i.z.number().positive(),data:i.z.unknown()});function F(t="socket"){return`${t}-${process.pid}-${l.default.randomBytes(8).toString("hex")}`}function x(t){const e=(0,h.getOsTmpDir)(),n=p.default.join(e,".socket-ipc",t);return p.default.join(n,`stub-${process.pid}.json`)}async function C(t){const e=p.default.dirname(t);await c.promises.mkdir(e,{recursive:!0})}async function H(t,e){const n=x(t);await C(n);const o={data:e,pid:process.pid,timestamp:Date.now()},s=I.parse(o);return await c.promises.writeFile(n,JSON.stringify(s,null,2),"utf8"),n}async function W(t){try{const e=await c.promises.readFile(t,"utf8"),n=JSON.parse(e),o=I.parse(n),s=Date.now()-o.timestamp,a=300*1e3;if(s>a){try{(0,g.safeDeleteSync)(t,{force:!0})}catch{}return null}return o.data}catch{return null}}async function z(t){const e=(0,h.getOsTmpDir)(),n=p.default.join(e,".socket-ipc",t);try{const o=await c.promises.readdir(n),s=Date.now(),a=300*1e3;await Promise.all(o.map(async r=>{if(r.startsWith("stub-")&&r.endsWith(".json")){const u=p.default.join(n,r);try{const b=await c.promises.stat(u);let f=s-b.mtimeMs>a;try{const M=await c.promises.readFile(u,"utf8"),T=JSON.parse(M),D=I.parse(T),j=s-D.timestamp;f=f||j>a}catch{}f&&(0,g.safeDeleteSync)(u,{force:!0})}catch{}}}))}catch{}}function _(t,e){if(t&&typeof t=="object"&&"send"in t&&typeof t.send=="function")try{const n=w.parse(e);return t.send(n)}catch{return!1}return!1}function S(t){const e=n=>{const o=v(n);o&&t(o)};return process.on("message",e),()=>{process.off("message",e)}}function q(t,e={}){const{timeout:n=3e4}=e;return new Promise((o,s)=>{let a=null,r=null;const u=()=>{a&&a(),s(new Error(`IPC timeout waiting for message type: ${t}`))};a=S(d=>{d.type===t&&(r&&clearTimeout(r),a&&a(),o(d.data))}),n>0&&(r=setTimeout(u,n))})}function G(t,e){return{id:l.default.randomBytes(16).toString("hex"),timestamp:Date.now(),type:t,data:e}}function K(t){return!!(t&&typeof t=="object"&&"send"in t&&typeof t.send=="function"&&"channel"in t&&t.channel!==void 0)}function v(t){try{return w.parse(t)}catch{return null}}0&&(module.exports={IpcHandshakeSchema,cleanupIpcStubs,createIpcChannelId,createIpcMessage,getIpcStubPath,hasIpcChannel,onIpc,parseIpcMessage,readIpcStub,sendIpc,waitForIpc,writeIpcStub});
+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 ipc_exports = {};
+__export(ipc_exports, {
+  IpcHandshakeSchema: () => IpcHandshakeSchema,
+  cleanupIpcStubs: () => cleanupIpcStubs,
+  createIpcChannelId: () => createIpcChannelId,
+  createIpcMessage: () => createIpcMessage,
+  getIpcStubPath: () => getIpcStubPath,
+  hasIpcChannel: () => hasIpcChannel,
+  onIpc: () => onIpc,
+  parseIpcMessage: () => parseIpcMessage,
+  readIpcStub: () => readIpcStub,
+  sendIpc: () => sendIpc,
+  waitForIpc: () => waitForIpc,
+  writeIpcStub: () => writeIpcStub
+});
+module.exports = __toCommonJS(ipc_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_fs2 = require("./fs");
+var import_paths = require("./paths");
+var import_zod = require("./zod");
+const IpcMessageSchema = import_zod.z.object({
+  /** Unique identifier for message tracking and response correlation. */
+  id: import_zod.z.string().min(1),
+  /** Unix timestamp for freshness validation and replay prevention. */
+  timestamp: import_zod.z.number().positive(),
+  /** Message type identifier for routing and handling. */
+  type: import_zod.z.string().min(1),
+  /** Payload data - can be any JSON-serializable value. */
+  data: import_zod.z.unknown()
+});
+const IpcHandshakeSchema = IpcMessageSchema.extend({
+  type: import_zod.z.literal("handshake"),
+  data: import_zod.z.object({
+    /** Protocol version for compatibility checking. */
+    version: import_zod.z.string(),
+    /** Process ID for identification. */
+    pid: import_zod.z.number().int().positive(),
+    /** Optional API token for authentication. */
+    apiToken: import_zod.z.string().optional(),
+    /** Application name for multi-app support. */
+    appName: import_zod.z.string()
+  })
+});
+const IpcStubSchema = import_zod.z.object({
+  /** Process ID that created the stub. */
+  pid: import_zod.z.number().int().positive(),
+  /** Creation timestamp for age validation. */
+  timestamp: import_zod.z.number().positive(),
+  /** The actual data payload. */
+  data: import_zod.z.unknown()
+});
+function createIpcChannelId(prefix = "socket") {
+  return `${prefix}-${process.pid}-${import_crypto.default.randomBytes(8).toString("hex")}`;
+}
+function getIpcStubPath(appName) {
+  const tempDir = (0, import_paths.getOsTmpDir)();
+  const stubDir = import_path.default.join(tempDir, ".socket-ipc", appName);
+  return import_path.default.join(stubDir, `stub-${process.pid}.json`);
+}
+async function ensureIpcDirectory(filePath) {
+  const dir = import_path.default.dirname(filePath);
+  await import_fs.promises.mkdir(dir, { recursive: true });
+}
+async function writeIpcStub(appName, data) {
+  const stubPath = getIpcStubPath(appName);
+  await ensureIpcDirectory(stubPath);
+  const ipcData = {
+    data,
+    pid: process.pid,
+    timestamp: Date.now()
+  };
+  const validated = IpcStubSchema.parse(ipcData);
+  await import_fs.promises.writeFile(stubPath, JSON.stringify(validated, null, 2), "utf8");
+  return stubPath;
+}
+async function readIpcStub(stubPath) {
+  try {
+    const content = await import_fs.promises.readFile(stubPath, "utf8");
+    const parsed = JSON.parse(content);
+    const validated = IpcStubSchema.parse(parsed);
+    const ageMs = Date.now() - validated.timestamp;
+    const maxAgeMs = 5 * 60 * 1e3;
+    if (ageMs > maxAgeMs) {
+      try {
+        (0, import_fs2.safeDeleteSync)(stubPath, { force: true });
+      } catch {
+      }
+      return null;
+    }
+    return validated.data;
+  } catch {
+    return null;
+  }
+}
+async function cleanupIpcStubs(appName) {
+  const tempDir = (0, import_paths.getOsTmpDir)();
+  const stubDir = import_path.default.join(tempDir, ".socket-ipc", appName);
+  try {
+    const files = await import_fs.promises.readdir(stubDir);
+    const now = Date.now();
+    const maxAgeMs = 5 * 60 * 1e3;
+    await Promise.all(
+      files.map(async (file) => {
+        if (file.startsWith("stub-") && file.endsWith(".json")) {
+          const filePath = import_path.default.join(stubDir, file);
+          try {
+            const stats = await import_fs.promises.stat(filePath);
+            const mtimeAge = now - stats.mtimeMs;
+            let isStale = mtimeAge > maxAgeMs;
+            try {
+              const content = await import_fs.promises.readFile(filePath, "utf8");
+              const parsed = JSON.parse(content);
+              const validated = IpcStubSchema.parse(parsed);
+              const contentAge = now - validated.timestamp;
+              isStale = isStale || contentAge > maxAgeMs;
+            } catch {
+            }
+            if (isStale) {
+              (0, import_fs2.safeDeleteSync)(filePath, { force: true });
+            }
+          } catch {
+          }
+        }
+      })
+    );
+  } catch {
+  }
+}
+function sendIpc(process2, message) {
+  if (process2 && typeof process2 === "object" && "send" in process2 && typeof process2.send === "function") {
+    try {
+      const validated = IpcMessageSchema.parse(message);
+      return process2.send(validated);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function onIpc(handler) {
+  const listener = (message) => {
+    const parsed = parseIpcMessage(message);
+    if (parsed) {
+      handler(parsed);
+    }
+  };
+  process.on("message", listener);
+  return () => {
+    process.off("message", listener);
+  };
+}
+function waitForIpc(messageType, options = {}) {
+  const { timeout = 3e4 } = options;
+  return new Promise((resolve, reject) => {
+    let cleanup = null;
+    let timeoutId = null;
+    const handleTimeout = () => {
+      if (cleanup) {
+        cleanup();
+      }
+      reject(new Error(`IPC timeout waiting for message type: ${messageType}`));
+    };
+    const handleMessage = (message) => {
+      if (message.type === messageType) {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (cleanup) {
+          cleanup();
+        }
+        resolve(message.data);
+      }
+    };
+    cleanup = onIpc(handleMessage);
+    if (timeout > 0) {
+      timeoutId = setTimeout(handleTimeout, timeout);
+    }
+  });
+}
+function createIpcMessage(type, data) {
+  return {
+    id: import_crypto.default.randomBytes(16).toString("hex"),
+    timestamp: Date.now(),
+    type,
+    data
+  };
+}
+function hasIpcChannel(process2) {
+  return Boolean(
+    process2 && typeof process2 === "object" && "send" in process2 && typeof process2.send === "function" && "channel" in process2 && process2.channel !== void 0
+  );
+}
+function parseIpcMessage(message) {
+  try {
+    const validated = IpcMessageSchema.parse(message);
+    return validated;
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IpcHandshakeSchema,
+  cleanupIpcStubs,
+  createIpcChannelId,
+  createIpcMessage,
+  getIpcStubPath,
+  hasIpcChannel,
+  onIpc,
+  parseIpcMessage,
+  readIpcStub,
+  sendIpc,
+  waitForIpc,
+  writeIpcStub
+});
 //# sourceMappingURL=ipc.js.map

package/dist/ipc.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/ipc.ts"],
   "sourcesContent": ["/**\n * IPC (Inter-Process Communication) Module\n * ==========================================\n *\n * This module provides secure inter-process communication utilities for Socket CLI\n * and related tools. It replaces environment variable passing with more secure and\n * scalable alternatives.\n *\n * ## Key Features:\n * - File-based stub communication for initial data handoff\n * - Node.js IPC channel support for real-time bidirectional messaging\n * - Automatic cleanup of temporary files\n * - Type-safe message validation with Zod schemas\n * - Timeout handling for reliability\n *\n * ## Use Cases:\n * 1. Passing API tokens between processes without exposing them in env vars\n * 2. Transferring large configuration objects that exceed env var size limits\n * 3. Bidirectional communication between parent and child processes\n * 4. Secure handshake protocols between Socket CLI components\n *\n * ## Security Considerations:\n * - Stub files are created with restricted permissions in OS temp directory\n * - Messages include timestamps for freshness validation\n * - Automatic cleanup prevents sensitive data persistence\n * - Unique IDs prevent message replay attacks\n *\n * @module ipc\n */\n\nimport crypto from 'crypto'\n\nimport { promises as fs } from 'fs'\n\nimport path from 'path'\n\nimport { safeDeleteSync } from './fs'\nimport { getOsTmpDir } from './paths'\nimport { z } from './zod'\n\n// Define BufferEncoding type for TypeScript compatibility.\ntype BufferEncoding = globalThis.BufferEncoding\n\n/**\n * Zod Schemas for Runtime Validation\n * ====================================\n * These schemas provide runtime type safety for IPC messages,\n * ensuring data integrity across process boundaries.\n */\n\n/**\n * Base IPC message schema - validates the core message structure.\n * All IPC messages must conform to this schema.\n */\nconst IpcMessageSchema = z.object({\n  /** Unique identifier for message tracking and response correlation. */\n  id: z.string().min(1),\n  /** Unix timestamp for freshness validation and replay prevention. */\n  timestamp: z.number().positive(),\n  /** Message type identifier for routing and handling. */\n  type: z.string().min(1),\n  /** Payload data - can be any JSON-serializable value. */\n  data: z.unknown(),\n})\n\n/**\n * IPC handshake schema - used for initial connection establishment.\n * The handshake includes version info and authentication tokens.\n * @internal Exported for testing purposes.\n */\nexport const IpcHandshakeSchema = IpcMessageSchema.extend({\n  type: z.literal('handshake'),\n  data: z.object({\n    /** Protocol version for compatibility checking. */\n    version: z.string(),\n    /** Process ID for identification. */\n    pid: z.number().int().positive(),\n    /** Optional API token for authentication. */\n    apiToken: z.string().optional(),\n    /** Application name for multi-app support. */\n    appName: z.string(),\n  }),\n})\n\n/**\n * IPC stub file schema - validates the structure of stub files.\n * Stub files are used for passing data between processes via filesystem.\n */\nconst IpcStubSchema = z.object({\n  /** Process ID that created the stub. */\n  pid: z.number().int().positive(),\n  /** Creation timestamp for age validation. */\n  timestamp: z.number().positive(),\n  /** The actual data payload. */\n  data: z.unknown(),\n})\n\n/**\n * TypeScript interfaces for IPC communication.\n * These types ensure type consistency across the IPC module.\n */\n\n/**\n * Base IPC message interface.\n * All IPC messages must conform to this structure.\n */\nexport interface IpcMessage<T = unknown> {\n  /** Unique identifier for message tracking and response correlation. */\n  id: string\n  /** Unix timestamp for freshness validation and replay prevention. */\n  timestamp: number\n  /** Message type identifier for routing and handling. */\n  type: string\n  /** Payload data - can be any JSON-serializable value. */\n  data: T\n}\n\n/**\n * IPC handshake message interface.\n * Used for initial connection establishment.\n */\nexport interface IpcHandshake\n  extends IpcMessage<{\n    /** Protocol version for compatibility checking. */\n    version: string\n    /** Process ID for identification. */\n    pid: number\n    /** Optional API token for authentication. */\n    apiToken?: string\n    /** Application name for multi-app support. */\n    appName: string\n  }> {\n  type: 'handshake'\n}\n\n/**\n * IPC stub file interface.\n * Represents the structure of stub files used for filesystem-based IPC.\n */\nexport interface IpcStub {\n  /** Process ID that created the stub. */\n  pid: number\n  /** Creation timestamp for age validation. */\n  timestamp: number\n  /** The actual data payload. */\n  data: unknown\n}\n\n/**\n * Options for IPC communication\n */\nexport interface IpcOptions {\n  /** Timeout in milliseconds for async operations. */\n  timeout?: number\n  /** Text encoding for message serialization. */\n  encoding?: BufferEncoding\n}\n\n/**\n * Create a unique IPC channel identifier for message correlation.\n *\n * Generates a unique identifier that combines:\n * - A prefix for namespacing (defaults to 'socket')\n * - The current process ID for process identification\n * - A random hex string for uniqueness\n *\n * @param prefix - Optional prefix to namespace the channel ID\n * @returns A unique channel identifier string\n *\n * @example\n * ```typescript\n * const channelId = createIpcChannelId('socket-cli')\n * // Returns: 'socket-cli-12345-a1b2c3d4e5f6g7h8'\n * ```\n */\nexport function createIpcChannelId(prefix = 'socket'): string {\n  return `${prefix}-${process.pid}-${crypto.randomBytes(8).toString('hex')}`\n}\n\n/**\n * Get the IPC stub path for a given application.\n *\n * This function generates a unique file path for IPC stub files that are used\n * to pass data between processes. The stub files are stored in a hidden directory\n * within the system's temporary folder.\n *\n * ## Path Structure:\n * - Base: System temp directory (e.g., /tmp on Unix, %TEMP% on Windows)\n * - Directory: `.socket-ipc/{appName}/`\n * - Filename: `stub-{pid}.json`\n *\n * ## Security Features:\n * - Files are isolated per application via appName parameter\n * - Process ID in filename prevents collisions between concurrent processes\n * - Temporary directory location ensures automatic cleanup on system restart\n *\n * @param appName - The application identifier (e.g., 'socket-cli', 'socket-dlx')\n * @returns Full path to the IPC stub file\n *\n * @example\n * ```typescript\n * const stubPath = getIpcStubPath('socket-cli')\n * // Returns: '/tmp/.socket-ipc/socket-cli/stub-12345.json' (Unix)\n * // Returns: 'C:\\\\Users\\\\Name\\\\AppData\\\\Local\\\\Temp\\\\.socket-ipc\\\\socket-cli\\\\stub-12345.json' (Windows)\n * ```\n *\n * @used Currently used by socket-cli for self-update and inter-process communication\n */\nexport function getIpcStubPath(appName: string): string {\n  // Get the system's temporary directory - this is platform-specific.\n  const tempDir = getOsTmpDir()\n\n  // Create a hidden directory structure for Socket IPC files.\n  // The dot prefix makes it hidden on Unix-like systems.\n  const stubDir = path.join(tempDir, '.socket-ipc', appName)\n\n  // Generate filename with process ID to ensure uniqueness.\n  // The PID prevents conflicts when multiple processes run simultaneously.\n  return path.join(stubDir, `stub-${process.pid}.json`)\n}\n\n/**\n * Ensure IPC directory exists for stub file creation.\n *\n * This helper function creates the directory structure needed for IPC stub files.\n * It's called before writing stub files to ensure the parent directories exist.\n *\n * @param filePath - Full path to the file that needs its directory created\n * @returns Promise that resolves when directory is created\n *\n * @internal Helper function used by writeIpcStub\n */\nasync function ensureIpcDirectory(filePath: string): Promise<void> {\n  const dir = path.dirname(filePath)\n  // Create directory recursively if it doesn't exist.\n  await fs.mkdir(dir, { recursive: true })\n}\n\n/**\n * Write IPC data to a stub file for inter-process data transfer.\n *\n * This function creates a stub file containing data that needs to be passed\n * between processes. The stub file includes metadata like process ID and\n * timestamp for validation.\n *\n * ## File Structure:\n * ```json\n * {\n *   \"pid\": 12345,\n *   \"timestamp\": 1699564234567,\n *   \"data\": { ... }\n * }\n * ```\n *\n * ## Use Cases:\n * - Passing API tokens to child processes\n * - Transferring configuration between Socket CLI components\n * - Sharing large data that exceeds environment variable limits\n *\n * @param appName - The application identifier\n * @param data - The data to write to the stub file\n * @returns Promise resolving to the stub file path\n *\n * @example\n * ```typescript\n * const stubPath = await writeIpcStub('socket-cli', {\n *   apiToken: 'secret-token',\n *   config: { ... }\n * })\n * // Pass stubPath to child process for reading\n * ```\n */\nexport async function writeIpcStub(\n  appName: string,\n  data: unknown,\n): Promise<string> {\n  const stubPath = getIpcStubPath(appName)\n  await ensureIpcDirectory(stubPath)\n\n  // Create stub data with validation metadata.\n  const ipcData: IpcStub = {\n    data,\n    pid: process.pid,\n    timestamp: Date.now(),\n  }\n\n  // Validate data structure with Zod schema.\n  const validated = IpcStubSchema.parse(ipcData)\n\n  // Write with pretty printing for debugging.\n  await fs.writeFile(stubPath, JSON.stringify(validated, null, 2), 'utf8')\n  return stubPath\n}\n\n/**\n * Read IPC data from a stub file with automatic cleanup.\n *\n * This function reads data from an IPC stub file and validates its freshness.\n * Stale files (older than 5 minutes) are automatically cleaned up to prevent\n * accumulation of temporary files.\n *\n * ## Validation Steps:\n * 1. Read and parse JSON file\n * 2. Validate structure with Zod schema\n * 3. Check timestamp freshness\n * 4. Clean up if stale\n * 5. Return data if valid\n *\n * @param stubPath - Path to the stub file to read\n * @returns Promise resolving to the data or null if invalid/stale\n *\n * @example\n * ```typescript\n * const data = await readIpcStub('/tmp/.socket-ipc/socket-cli/stub-12345.json')\n * if (data) {\n *   console.log('Received:', data)\n * }\n * ```\n *\n * @unused Reserved for future implementation\n */\nexport async function readIpcStub(stubPath: string): Promise<unknown> {\n  try {\n    const content = await fs.readFile(stubPath, 'utf8')\n    const parsed = JSON.parse(content)\n    // Validate structure with Zod schema.\n    const validated = IpcStubSchema.parse(parsed)\n    // Check age for freshness validation.\n    const ageMs = Date.now() - validated.timestamp\n    // 5 minutes.\n    const maxAgeMs = 5 * 60 * 1000\n    if (ageMs > maxAgeMs) {\n      // Clean up stale file. IPC stubs are always in tmpdir, so use force: true.\n      try {\n        safeDeleteSync(stubPath, { force: true })\n      } catch {\n        // Ignore deletion errors\n      }\n      return null\n    }\n    return validated.data\n  } catch {\n    // Return null for any errors (file not found, invalid JSON, validation failure).\n    return null\n  }\n}\n\n/**\n * Clean up IPC stub files for an application.\n *\n * This maintenance function removes stale IPC stub files to prevent\n * accumulation in the temporary directory. It's designed to be called\n * periodically or on application startup.\n *\n * ## Cleanup Rules:\n * - Files older than 5 minutes are removed (checked via both filesystem mtime and JSON timestamp)\n * - Only stub files (stub-*.json) are processed\n * - Errors are silently ignored (best-effort cleanup)\n *\n * @param appName - The application identifier\n * @returns Promise that resolves when cleanup is complete\n *\n * @example\n * ```typescript\n * // Clean up on application startup\n * await cleanupIpcStubs('socket-cli')\n * ```\n *\n * @unused Reserved for future implementation\n */\nexport async function cleanupIpcStubs(appName: string): Promise<void> {\n  const tempDir = getOsTmpDir()\n  const stubDir = path.join(tempDir, '.socket-ipc', appName)\n  try {\n    const files = await fs.readdir(stubDir)\n    const now = Date.now()\n    // 5 minutes.\n    const maxAgeMs = 5 * 60 * 1000\n    // Process each file in parallel for efficiency.\n    await Promise.all(\n      files.map(async file => {\n        if (file.startsWith('stub-') && file.endsWith('.json')) {\n          const filePath = path.join(stubDir, file)\n          try {\n            // Check both filesystem mtime and JSON timestamp for more reliable detection\n            const stats = await fs.stat(filePath)\n            const mtimeAge = now - stats.mtimeMs\n            let isStale = mtimeAge > maxAgeMs\n\n            // Always check the timestamp inside the JSON file for accuracy\n            // This is more reliable than filesystem mtime in some environments\n            try {\n              const content = await fs.readFile(filePath, 'utf8')\n              const parsed = JSON.parse(content)\n              const validated = IpcStubSchema.parse(parsed)\n              const contentAge = now - validated.timestamp\n              // File is stale if EITHER check indicates staleness\n              isStale = isStale || contentAge > maxAgeMs\n            } catch {\n              // If we can't read/parse the file, rely on mtime check\n            }\n\n            if (isStale) {\n              // IPC stubs are always in tmpdir, so we can use force: true to skip path checks\n              safeDeleteSync(filePath, { force: true })\n            }\n          } catch {\n            // Ignore errors for individual files.\n          }\n        }\n      }),\n    )\n  } catch {\n    // Directory might not exist, that's ok.\n  }\n}\n\n/**\n * Send data through Node.js IPC channel.\n *\n * This function sends structured messages through the Node.js IPC channel\n * when available. The IPC channel must be established with stdio: ['pipe', 'pipe', 'pipe', 'ipc'].\n *\n * ## Requirements:\n * - Process must have been spawned with IPC channel enabled\n * - Message must be serializable to JSON\n * - Process.send() must be available\n *\n * @param process - The process object with IPC channel\n * @param message - The IPC message to send\n * @returns true if message was sent, false otherwise\n *\n * @example\n * ```typescript\n * const message = createIpcMessage('handshake', { version: '1.0.0' })\n * const sent = sendIpc(childProcess, message)\n * ```\n *\n * @unused Reserved for bidirectional communication implementation\n */\nexport function sendIpc(\n  process: NodeJS.Process | unknown,\n  message: IpcMessage,\n): boolean {\n  if (\n    process &&\n    typeof process === 'object' &&\n    'send' in process &&\n    typeof process.send === 'function'\n  ) {\n    try {\n      // Validate message structure before sending.\n      const validated = IpcMessageSchema.parse(message)\n      return process.send(validated)\n    } catch {\n      return false\n    }\n  }\n  return false\n}\n\n/**\n * Receive data through Node.js IPC channel.\n *\n * Sets up a listener for IPC messages with automatic validation and parsing.\n * Returns a cleanup function to remove the listener when no longer needed.\n *\n * ## Message Flow:\n * 1. Receive raw message from IPC channel\n * 2. Validate with parseIpcMessage\n * 3. Call handler if valid\n * 4. Ignore invalid messages\n *\n * @param handler - Function to call with valid IPC messages\n * @returns Cleanup function to remove the listener\n *\n * @example\n * ```typescript\n * const cleanup = onIpc((message) => {\n *   console.log('Received:', message.type, message.data)\n * })\n * // Later...\n * cleanup() // Remove listener\n * ```\n *\n * @unused Reserved for bidirectional communication\n */\nexport function onIpc(handler: (message: IpcMessage) => void): () => void {\n  const listener = (message: unknown) => {\n    const parsed = parseIpcMessage(message)\n    if (parsed) {\n      handler(parsed)\n    }\n  }\n  process.on('message', listener)\n  // Return cleanup function for proper resource management.\n  return () => {\n    process.off('message', listener)\n  }\n}\n\n/**\n * Create a promise that resolves when a specific IPC message is received.\n *\n * This utility function provides async/await support for IPC communication,\n * allowing you to wait for specific message types with timeout support.\n *\n * ## Features:\n * - Automatic timeout handling\n * - Type-safe message data\n * - Resource cleanup on completion\n * - Promise-based API\n *\n * @param messageType - The message type to wait for\n * @param options - Options including timeout configuration\n * @returns Promise resolving to the message data\n *\n * @example\n * ```typescript\n * try {\n *   const response = await waitForIpc<ConfigData>('config-response', {\n *     timeout: 5000 // 5 seconds\n *   })\n *   console.log('Config received:', response)\n * } catch (error) {\n *   console.error('Timeout waiting for config')\n * }\n * ```\n *\n * @unused Reserved for request-response pattern implementation\n */\nexport function waitForIpc<T = unknown>(\n  messageType: string,\n  options: IpcOptions = {},\n): Promise<T> {\n  const { timeout = 30_000 } = options\n  return new Promise((resolve, reject) => {\n    let cleanup: (() => void) | null = null\n    let timeoutId: NodeJS.Timeout | null = null\n    const handleTimeout = () => {\n      if (cleanup) {\n        cleanup()\n      }\n      reject(new Error(`IPC timeout waiting for message type: ${messageType}`))\n    }\n    const handleMessage = (message: IpcMessage) => {\n      if (message.type === messageType) {\n        if (timeoutId) {\n          clearTimeout(timeoutId)\n        }\n        if (cleanup) {\n          cleanup()\n        }\n        resolve(message.data as T)\n      }\n    }\n    cleanup = onIpc(handleMessage)\n    if (timeout > 0) {\n      timeoutId = setTimeout(handleTimeout, timeout)\n    }\n  })\n}\n\n/**\n * Create an IPC message with proper structure and metadata.\n *\n * This factory function creates properly structured IPC messages with:\n * - Unique ID for tracking\n * - Timestamp for freshness\n * - Type for routing\n * - Data payload\n *\n * @param type - The message type identifier\n * @param data - The message payload\n * @returns A properly structured IPC message\n *\n * @example\n * ```typescript\n * const handshake = createIpcMessage('handshake', {\n *   version: '1.0.0',\n *   pid: process.pid,\n *   appName: 'socket-cli'\n * })\n * ```\n *\n * @unused Reserved for future message creation needs\n */\nexport function createIpcMessage<T = unknown>(\n  type: string,\n  data: T,\n): IpcMessage<T> {\n  return {\n    id: crypto.randomBytes(16).toString('hex'),\n    timestamp: Date.now(),\n    type,\n    data,\n  }\n}\n\n/**\n * Check if process has IPC channel available.\n *\n * This utility checks whether a process object has the necessary\n * properties for IPC communication. Used to determine if IPC\n * messaging is possible before attempting to send.\n *\n * @param process - The process object to check\n * @returns true if IPC is available, false otherwise\n *\n * @example\n * ```typescript\n * if (hasIpcChannel(childProcess)) {\n *   sendIpc(childProcess, message)\n * } else {\n *   // Fall back to alternative communication method\n * }\n * ```\n *\n * @unused Reserved for IPC availability detection\n */\nexport function hasIpcChannel(process: unknown): boolean {\n  return Boolean(\n    process &&\n      typeof process === 'object' &&\n      'send' in process &&\n      typeof process.send === 'function' &&\n      'channel' in process &&\n      process.channel !== undefined,\n  )\n}\n\n/**\n * Safely parse and validate IPC messages.\n *\n * This function performs runtime validation of incoming messages\n * to ensure they conform to the IPC message structure. It uses\n * Zod schemas for robust validation.\n *\n * ## Validation Steps:\n * 1. Check if message is an object\n * 2. Validate required fields exist\n * 3. Validate field types\n * 4. Return typed message or null\n *\n * @param message - The raw message to parse\n * @returns Parsed IPC message or null if invalid\n *\n * @example\n * ```typescript\n * const parsed = parseIpcMessage(rawMessage)\n * if (parsed) {\n *   handleMessage(parsed)\n * }\n * ```\n *\n * @unused Reserved for message validation needs\n */\nexport function parseIpcMessage(message: unknown): IpcMessage | null {\n  try {\n    // Use Zod schema for comprehensive validation.\n    const validated = IpcMessageSchema.parse(message)\n    return validated as IpcMessage\n  } catch {\n    // Return null for any validation failure.\n    return null\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["ipc_exports", "__export", "IpcHandshakeSchema", "cleanupIpcStubs", "createIpcChannelId", "createIpcMessage", "getIpcStubPath", "hasIpcChannel", "onIpc", "parseIpcMessage", "readIpcStub", "sendIpc", "waitForIpc", "writeIpcStub", "__toCommonJS", "import_crypto", "import_fs", "import_path", "import_paths", "import_zod", "IpcMessageSchema", "IpcStubSchema", "prefix", "crypto", "appName", "tempDir", "stubDir", "path", "ensureIpcDirectory", "filePath", "dir", "fs", "data", "stubPath", "ipcData", "validated", "content", "parsed", "ageMs", "maxAgeMs", "files", "now", "file", "stats", "isStale", "contentAge", "process", "message", "handler", "listener", "messageType", "options", "timeout", "resolve", "reject", "cleanup", "timeoutId", "handleTimeout", "type"]
+  "mappings": "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",
+  "names": ["import_fs", "crypto", "path", "fs", "process"]
 }

package/dist/json.js

@@ -1,3 +1,75 @@
 /* Socket Lib - Built with esbuild */
-var i=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var d=(n,e)=>{for(var r in e)i(n,r,{get:e[r],enumerable:!0})},J=(n,e,r,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of l(e))!y.call(n,o)&&o!==r&&i(n,o,{get:()=>e[o],enumerable:!(t=c(e,o))||t.enumerable});return n};var m=n=>J(i({},"__esModule",{value:!0}),n);var w={};d(w,{isJsonPrimitive:()=>h,jsonParse:()=>v});module.exports=m(w);var f=require("./strings");const g=JSON.parse;function b(n){if(!n||typeof n!="object")return!1;const e=n;if(typeof e.length!="number"||typeof e.copy!="function"||typeof e.slice!="function"||typeof e.length=="number"&&e.length>0&&typeof e[0]!="number")return!1;const r=n.constructor;return!!(typeof r?.isBuffer=="function"&&r.isBuffer(n))}function h(n){return n===null||typeof n=="boolean"||typeof n=="number"||typeof n=="string"}function v(n,e){const{filepath:r,reviver:t,throws:o}={__proto__:null,...e},u=o===void 0||!!o,a=b(n)?n.toString("utf8"):n;try{return g((0,f.stripBom)(a),t)}catch(p){if(u){const s=p;throw s&&typeof r=="string"&&(s.message=`${r}: ${s.message}`),s}}}0&&(module.exports={isJsonPrimitive,jsonParse});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_exports = {};
+__export(json_exports, {
+  isJsonPrimitive: () => isJsonPrimitive,
+  jsonParse: () => jsonParse
+});
+module.exports = __toCommonJS(json_exports);
+var import_strings = require("./strings");
+const JSONParse = JSON.parse;
+// @__NO_SIDE_EFFECTS__
+function isBuffer(x) {
+  if (!x || typeof x !== "object") {
+    return false;
+  }
+  const obj = x;
+  if (typeof obj["length"] !== "number") {
+    return false;
+  }
+  if (typeof obj["copy"] !== "function" || typeof obj["slice"] !== "function") {
+    return false;
+  }
+  if (typeof obj["length"] === "number" && obj["length"] > 0 && typeof obj[0] !== "number") {
+    return false;
+  }
+  const Ctor = x.constructor;
+  return !!(typeof Ctor?.isBuffer === "function" && Ctor.isBuffer(x));
+}
+// @__NO_SIDE_EFFECTS__
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
+}
+// @__NO_SIDE_EFFECTS__
+function jsonParse(content, options) {
+  const { filepath, reviver, throws } = {
+    __proto__: null,
+    ...options
+  };
+  const shouldThrow = throws === void 0 || !!throws;
+  const jsonStr = /* @__PURE__ */ isBuffer(content) ? content.toString("utf8") : content;
+  try {
+    return JSONParse((0, import_strings.stripBom)(jsonStr), reviver);
+  } catch (e) {
+    if (shouldThrow) {
+      const error = e;
+      if (error && typeof filepath === "string") {
+        error.message = `${filepath}: ${error.message}`;
+      }
+      throw error;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isJsonPrimitive,
+  jsonParse
+});
 //# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/json.ts"],
   "sourcesContent": ["/**\n * @fileoverview JSON parsing utilities with Buffer detection and BOM stripping.\n * Provides safe JSON parsing with automatic encoding handling.\n */\n\nimport { stripBom } from './strings'\n\n/**\n * JSON primitive types: `null`, `boolean`, `number`, or `string`.\n *\n * @example\n * ```ts\n * const primitives: JsonPrimitive[] = [null, true, 42, 'hello']\n * ```\n */\nexport type JsonPrimitive = null | boolean | number | string\n\n/**\n * Any valid JSON value: primitive, object, or array.\n *\n * @example\n * ```ts\n * const values: JsonValue[] = [\n *   null,\n *   true,\n *   42,\n *   'hello',\n *   { key: 'value' },\n *   [1, 2, 3]\n * ]\n * ```\n */\nexport type JsonValue = JsonPrimitive | JsonObject | JsonArray\n\n/**\n * A JSON object with string keys and JSON values.\n *\n * @example\n * ```ts\n * const obj: JsonObject = {\n *   name: 'example',\n *   count: 42,\n *   active: true,\n *   nested: { key: 'value' }\n * }\n * ```\n */\nexport interface JsonObject {\n  [key: string]: JsonValue\n}\n\n/**\n * A JSON array containing JSON values.\n *\n * @example\n * ```ts\n * const arr: JsonArray = [1, 'two', { three: 3 }, [4, 5]]\n * ```\n */\nexport interface JsonArray extends Array<JsonValue> {}\n\n/**\n * Reviver function for transforming parsed JSON values.\n * Called for each key-value pair during parsing.\n *\n * @param key - The object key or array index being parsed\n * @param value - The parsed value\n * @returns The transformed value (or original if no transform needed)\n *\n * @example\n * ```ts\n * // Convert date strings to Date objects\n * const reviver: JsonReviver = (key, value) => {\n *   if (typeof value === 'string' && /^\\d{4}-\\d{2}-\\d{2}/.test(value)) {\n *     return new Date(value)\n *   }\n *   return value\n * }\n * ```\n */\nexport type JsonReviver = (key: string, value: unknown) => unknown\n\n/**\n * Options for JSON parsing operations.\n */\nexport interface JsonParseOptions {\n  /**\n   * Optional filepath for improved error messages.\n   * When provided, errors will be prefixed with the filepath.\n   *\n   * @example\n   * ```ts\n   * // Error message will be: \"config.json: Unexpected token } in JSON\"\n   * jsonParse('invalid', { filepath: 'config.json' })\n   * ```\n   */\n  filepath?: string | undefined\n  /**\n   * Optional reviver function to transform parsed values.\n   * Called for each key-value pair during parsing.\n   *\n   * @example\n   * ```ts\n   * // Convert ISO date strings to Date objects\n   * const options = {\n   *   reviver: (key, value) => {\n   *     if (typeof value === 'string' && /^\\d{4}-\\d{2}-\\d{2}/.test(value)) {\n   *       return new Date(value)\n   *     }\n   *     return value\n   *   }\n   * }\n   * ```\n   */\n  reviver?: JsonReviver | undefined\n  /**\n   * Whether to throw on parse errors.\n   * When `false`, returns `undefined` instead of throwing.\n   *\n   * @default true\n   *\n   * @example\n   * ```ts\n   * // Throws error\n   * jsonParse('invalid', { throws: true })\n   *\n   * // Returns undefined\n   * const result = jsonParse('invalid', { throws: false })\n   * ```\n   */\n  throws?: boolean | undefined\n}\n\n// IMPORTANT: Do not use destructuring here - use direct assignment instead.\n// tsgo has a bug that incorrectly transpiles destructured exports, resulting in\n// `exports.SomeName = void 0;` which causes runtime errors.\n// See: https://github.com/SocketDev/socket-packageurl-js/issues/3\nconst JSONParse = JSON.parse\n\n/**\n * Check if a value is a Buffer instance.\n * Uses duck-typing to detect Buffer without requiring Node.js Buffer in type system.\n *\n * @param x - Value to check\n * @returns `true` if value is a Buffer, `false` otherwise\n *\n * @example\n * ```ts\n * isBuffer(Buffer.from('hello')) // => true\n * isBuffer('hello') // => false\n * isBuffer({ length: 5 }) // => false\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction isBuffer(x: unknown): x is Buffer {\n  if (!x || typeof x !== 'object') {\n    return false\n  }\n  const obj = x as Record<string | number, unknown>\n  if (typeof obj['length'] !== 'number') {\n    return false\n  }\n  if (typeof obj['copy'] !== 'function' || typeof obj['slice'] !== 'function') {\n    return false\n  }\n  if (\n    typeof obj['length'] === 'number' &&\n    obj['length'] > 0 &&\n    typeof obj[0] !== 'number'\n  ) {\n    return false\n  }\n\n  const Ctor = (x as { constructor?: unknown }).constructor as\n    | { isBuffer?: unknown }\n    | undefined\n  return !!(typeof Ctor?.isBuffer === 'function' && Ctor.isBuffer(x))\n}\n\n/**\n * Check if a value is a JSON primitive type.\n * JSON primitives are: `null`, `boolean`, `number`, or `string`.\n *\n * @param value - Value to check\n * @returns `true` if value is a JSON primitive, `false` otherwise\n *\n * @example\n * ```ts\n * isJsonPrimitive(null) // => true\n * isJsonPrimitive(true) // => true\n * isJsonPrimitive(42) // => true\n * isJsonPrimitive('hello') // => true\n * isJsonPrimitive({}) // => false\n * isJsonPrimitive([]) // => false\n * isJsonPrimitive(undefined) // => false\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isJsonPrimitive(value: unknown): value is JsonPrimitive {\n  return (\n    value === null ||\n    typeof value === 'boolean' ||\n    typeof value === 'number' ||\n    typeof value === 'string'\n  )\n}\n\n/**\n * Parse JSON content with automatic Buffer handling and BOM stripping.\n * Provides safer JSON parsing with helpful error messages and optional error suppression.\n *\n * Features:\n * - Automatic UTF-8 Buffer conversion\n * - BOM (Byte Order Mark) stripping for cross-platform compatibility\n * - Enhanced error messages with filepath context\n * - Optional error suppression (returns `undefined` instead of throwing)\n * - Optional reviver for transforming parsed values\n *\n * @param content - JSON string or Buffer to parse\n * @param options - Optional parsing configuration\n * @returns Parsed JSON value, or `undefined` if parsing fails and `throws` is `false`\n *\n * @throws {SyntaxError} When JSON is invalid and `throws` is `true` (default)\n *\n * @example\n * ```ts\n * // Basic usage\n * const data = jsonParse('{\"name\":\"example\"}')\n * console.log(data.name) // => 'example'\n *\n * // Parse Buffer with UTF-8 BOM\n * const buffer = Buffer.from('\\uFEFF{\"value\":42}')\n * const data = jsonParse(buffer)\n * console.log(data.value) // => 42\n *\n * // Enhanced error messages with filepath\n * try {\n *   jsonParse('invalid', { filepath: 'config.json' })\n * } catch (err) {\n *   console.error(err.message)\n *   // => \"config.json: Unexpected token i in JSON at position 0\"\n * }\n *\n * // Suppress errors\n * const result = jsonParse('invalid', { throws: false })\n * console.log(result) // => undefined\n *\n * // Transform values with reviver\n * const json = '{\"created\":\"2024-01-15T10:30:00Z\"}'\n * const data = jsonParse(json, {\n *   reviver: (key, value) => {\n *     if (key === 'created' && typeof value === 'string') {\n *       return new Date(value)\n *     }\n *     return value\n *   }\n * })\n * console.log(data.created instanceof Date) // => true\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function jsonParse(\n  content: string | Buffer,\n  options?: JsonParseOptions | undefined,\n): JsonValue | undefined {\n  const { filepath, reviver, throws } = {\n    __proto__: null,\n    ...options,\n  } as JsonParseOptions\n  const shouldThrow = throws === undefined || !!throws\n  const jsonStr = isBuffer(content) ? content.toString('utf8') : content\n  try {\n    return JSONParse(stripBom(jsonStr), reviver)\n  } catch (e) {\n    if (shouldThrow) {\n      const error = e as Error\n      if (error && typeof filepath === 'string') {\n        error.message = `${filepath}: ${error.message}`\n      }\n      throw error\n    }\n  }\n  return undefined\n}\n"],
-  "mappings": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,qBAAAE,EAAA,cAAAC,IAAA,eAAAC,EAAAJ,GAKA,IAAAK,EAAyB,qBAoIzB,MAAMC,EAAY,KAAK,MAiBvB,SAASC,EAASC,EAAyB,CACzC,GAAI,CAACA,GAAK,OAAOA,GAAM,SACrB,MAAO,GAET,MAAMC,EAAMD,EAOZ,GANI,OAAOC,EAAI,QAAc,UAGzB,OAAOA,EAAI,MAAY,YAAc,OAAOA,EAAI,OAAa,YAI/D,OAAOA,EAAI,QAAc,UACzBA,EAAI,OAAY,GAChB,OAAOA,EAAI,CAAC,GAAM,SAElB,MAAO,GAGT,MAAMC,EAAQF,EAAgC,YAG9C,MAAO,CAAC,EAAE,OAAOE,GAAM,UAAa,YAAcA,EAAK,SAASF,CAAC,EACnE,CAqBO,SAASN,EAAgBS,EAAwC,CACtE,OACEA,IAAU,MACV,OAAOA,GAAU,WACjB,OAAOA,GAAU,UACjB,OAAOA,GAAU,QAErB,CAwDO,SAASR,EACdS,EACAC,EACuB,CACvB,KAAM,CAAE,SAAAC,EAAU,QAAAC,EAAS,OAAAC,CAAO,EAAI,CACpC,UAAW,KACX,GAAGH,CACL,EACMI,EAAcD,IAAW,QAAa,CAAC,CAACA,EACxCE,EAAUX,EAASK,CAAO,EAAIA,EAAQ,SAAS,MAAM,EAAIA,EAC/D,GAAI,CACF,OAAON,KAAU,YAASY,CAAO,EAAGH,CAAO,CAC7C,OAASI,EAAG,CACV,GAAIF,EAAa,CACf,MAAMG,EAAQD,EACd,MAAIC,GAAS,OAAON,GAAa,WAC/BM,EAAM,QAAU,GAAGN,CAAQ,KAAKM,EAAM,OAAO,IAEzCA,CACR,CACF,CAEF",
-  "names": ["json_exports", "__export", "isJsonPrimitive", "jsonParse", "__toCommonJS", "import_strings", "JSONParse", "isBuffer", "x", "obj", "Ctor", "value", "content", "options", "filepath", "reviver", "throws", "shouldThrow", "jsonStr", "e", "error"]
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,qBAAyB;AAoIzB,MAAM,YAAY,KAAK;AAAA;AAiBvB,SAAS,SAAS,GAAyB;AACzC,MAAI,CAAC,KAAK,OAAO,MAAM,UAAU;AAC/B,WAAO;AAAA,EACT;AACA,QAAM,MAAM;AACZ,MAAI,OAAO,IAAI,QAAQ,MAAM,UAAU;AACrC,WAAO;AAAA,EACT;AACA,MAAI,OAAO,IAAI,MAAM,MAAM,cAAc,OAAO,IAAI,OAAO,MAAM,YAAY;AAC3E,WAAO;AAAA,EACT;AACA,MACE,OAAO,IAAI,QAAQ,MAAM,YACzB,IAAI,QAAQ,IAAI,KAChB,OAAO,IAAI,CAAC,MAAM,UAClB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,OAAQ,EAAgC;AAG9C,SAAO,CAAC,EAAE,OAAO,MAAM,aAAa,cAAc,KAAK,SAAS,CAAC;AACnE;AAAA;AAqBO,SAAS,gBAAgB,OAAwC;AACtE,SACE,UAAU,QACV,OAAO,UAAU,aACjB,OAAO,UAAU,YACjB,OAAO,UAAU;AAErB;AAAA;AAwDO,SAAS,UACd,SACA,SACuB;AACvB,QAAM,EAAE,UAAU,SAAS,OAAO,IAAI;AAAA,IACpC,WAAW;AAAA,IACX,GAAG;AAAA,EACL;AACA,QAAM,cAAc,WAAW,UAAa,CAAC,CAAC;AAC9C,QAAM,UAAU,yBAAS,OAAO,IAAI,QAAQ,SAAS,MAAM,IAAI;AAC/D,MAAI;AACF,WAAO,cAAU,yBAAS,OAAO,GAAG,OAAO;AAAA,EAC7C,SAAS,GAAG;AACV,QAAI,aAAa;AACf,YAAM,QAAQ;AACd,UAAI,SAAS,OAAO,aAAa,UAAU;AACzC,cAAM,UAAU,GAAG,QAAQ,KAAK,MAAM,OAAO;AAAA,MAC/C;AACA,YAAM;AAAA,IACR;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": []
 }

package/dist/links/index.js

@@ -1,3 +1,62 @@
 /* Socket Lib - Built with esbuild */
-var k=Object.create;var l=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var d=Object.getPrototypeOf,T=Object.prototype.hasOwnProperty;var C=(e,o)=>{for(var r in o)l(e,r,{get:o[r],enumerable:!0})},a=(e,o,r,t)=>{if(o&&typeof o=="object"||typeof o=="function")for(let n of u(o))!T.call(e,n)&&n!==r&&l(e,n,{get:()=>o[n],enumerable:!(t=g(o,n))||t.enumerable});return e};var b=(e,o,r)=>(r=e!=null?k(d(e)):{},a(o||!e||!e.__esModule?l(r,"default",{value:e,enumerable:!0}):r,e)),L=e=>a(l({},"__esModule",{value:!0}),e);var O={};C(O,{link:()=>y,links:()=>N});module.exports=L(O);var c=b(require("../external/yoctocolors-cjs")),f=require("../themes/context"),h=require("../themes/utils");function y(e,o,r){const t={__proto__:null,fallback:!1,...r},n=typeof t.theme=="string"?require("../themes/themes").THEMES[t.theme]:t.theme??(0,f.getTheme)(),s=(0,h.resolveColor)(n.colors.link,n.colors),m=c.default;let i;if(typeof s=="string"&&s!=="inherit"){const p=m[s];i=p?p(e):m.cyan(e)}else Array.isArray(s),i=m.cyan(e);return t.fallback?`${i} (${o})`:i}function N(e,o){return e.map(([r,t])=>y(r,t,o))}0&&(module.exports={link,links});
+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 links_exports = {};
+__export(links_exports, {
+  link: () => link,
+  links: () => links
+});
+module.exports = __toCommonJS(links_exports);
+var import_yoctocolors_cjs = __toESM(require("../external/yoctocolors-cjs"));
+var import_context = require("../themes/context");
+var import_utils = require("../themes/utils");
+function link(text, url, options) {
+  const opts = { __proto__: null, fallback: false, ...options };
+  const theme = typeof opts.theme === "string" ? require("../themes/themes").THEMES[opts.theme] : opts.theme ?? (0, import_context.getTheme)();
+  const linkColor = (0, import_utils.resolveColor)(theme.colors.link, theme.colors);
+  const colors = import_yoctocolors_cjs.default;
+  let colored;
+  if (typeof linkColor === "string" && linkColor !== "inherit") {
+    const colorMethod = colors[linkColor];
+    colored = colorMethod ? colorMethod(text) : colors.cyan(text);
+  } else if (Array.isArray(linkColor)) {
+    colored = colors.cyan(text);
+  } else {
+    colored = colors.cyan(text);
+  }
+  return opts.fallback ? `${colored} (${url})` : colored;
+}
+function links(linkSpecs, options) {
+  return linkSpecs.map(([text, url]) => link(text, url, options));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  link,
+  links
+});
 //# sourceMappingURL=index.js.map

package/dist/links/index.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/links/index.ts"],
   "sourcesContent": ["/**\n * @fileoverview Themed hyperlink utilities for terminal output.\n * Provides colored hyperlinks using theme configuration.\n */\n\nimport yoctocolorsCjs from '../external/yoctocolors-cjs'\nimport type { ColorName } from '../spinner'\nimport { getTheme } from '../themes/context'\nimport { resolveColor } from '../themes/utils'\nimport type { Theme } from '../themes/types'\nimport type { ThemeName } from '../themes/themes'\n\n/**\n * Options for creating themed links.\n */\nexport type LinkOptions = {\n  /** Theme to use (overrides global) */\n  theme?: Theme | ThemeName | undefined\n  /** Show URL as fallback if terminal doesn't support links */\n  fallback?: boolean | undefined\n}\n\n/**\n * Create a themed hyperlink for terminal output.\n * The link text is colored using the theme's link color.\n *\n * Note: Most terminals support ANSI color codes but not clickable links.\n * This function colors the text but does not create clickable hyperlinks.\n * For clickable links, use a library like 'terminal-link' separately.\n *\n * @param text - Link text to display\n * @param url - URL (included in fallback mode)\n * @param options - Link configuration options\n * @returns Colored link text\n *\n * @example\n * ```ts\n * import { link } from '@socketsecurity/lib/links'\n *\n * // Use current theme\n * console.log(link('Documentation', 'https://socket.dev'))\n *\n * // Override theme\n * console.log(link('API Docs', 'https://api.socket.dev', {\n *   theme: 'coana'\n * }))\n *\n * // Show URL as fallback\n * console.log(link('GitHub', 'https://github.com', {\n *   fallback: true\n * }))\n * // Output: \"GitHub (https://github.com)\"\n * ```\n */\nexport function link(text: string, url: string, options?: LinkOptions): string {\n  const opts = { __proto__: null, fallback: false, ...options } as LinkOptions\n\n  // Resolve theme\n  const theme =\n    typeof opts.theme === 'string'\n      ? require('../themes/themes').THEMES[opts.theme]\n      : (opts.theme ?? getTheme())\n\n  // Resolve link color\n  const linkColor = resolveColor(theme.colors.link, theme.colors)\n\n  // Apply color - for now just use cyan as a simple fallback\n  // Note: RGB color support to be added in yoctocolors wrapper\n  const colors = yoctocolorsCjs\n  let colored: string\n  if (typeof linkColor === 'string' && linkColor !== 'inherit') {\n    // Use named color method if available\n    const colorMethod = colors[linkColor as ColorName]\n    colored = colorMethod ? colorMethod(text) : colors.cyan(text)\n  } else if (Array.isArray(linkColor)) {\n    // RGB color - for now fallback to cyan\n    // Note: RGB color support to be implemented\n    colored = colors.cyan(text)\n  } else {\n    colored = colors.cyan(text)\n  }\n\n  // Return with or without URL fallback\n  return opts.fallback ? `${colored} (${url})` : colored\n}\n\n/**\n * Create multiple themed links from an array of link specifications.\n *\n * @param links - Array of [text, url] pairs\n * @param options - Link configuration options\n * @returns Array of colored link texts\n *\n * @example\n * ```ts\n * import { links } from '@socketsecurity/lib/links'\n *\n * const formatted = links([\n *   ['Documentation', 'https://socket.dev'],\n *   ['API Reference', 'https://api.socket.dev'],\n *   ['GitHub', 'https://github.com/SocketDev']\n * ])\n *\n * formatted.forEach(link => console.log(link))\n * ```\n */\nexport function links(\n  linkSpecs: Array<[text: string, url: string]>,\n  options?: LinkOptions,\n): string[] {\n  return linkSpecs.map(([text, url]) => link(text, url, options))\n}\n"],
-  "mappings": ";6iBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,UAAAE,EAAA,UAAAC,IAAA,eAAAC,EAAAJ,GAKA,IAAAK,EAA2B,0CAE3BC,EAAyB,6BACzBC,EAA6B,2BA8CtB,SAASL,EAAKM,EAAcC,EAAaC,EAA+B,CAC7E,MAAMC,EAAO,CAAE,UAAW,KAAM,SAAU,GAAO,GAAGD,CAAQ,EAGtDE,EACJ,OAAOD,EAAK,OAAU,SAClB,QAAQ,kBAAkB,EAAE,OAAOA,EAAK,KAAK,EAC5CA,EAAK,UAAS,YAAS,EAGxBE,KAAY,gBAAaD,EAAM,OAAO,KAAMA,EAAM,MAAM,EAIxDE,EAAS,EAAAC,QACf,IAAIC,EACJ,GAAI,OAAOH,GAAc,UAAYA,IAAc,UAAW,CAE5D,MAAMI,EAAcH,EAAOD,CAAsB,EACjDG,EAAUC,EAAcA,EAAYT,CAAI,EAAIM,EAAO,KAAKN,CAAI,CAC9D,MAAW,MAAM,QAAQK,CAAS,EAGhCG,EAAUF,EAAO,KAAKN,CAAI,EAM5B,OAAOG,EAAK,SAAW,GAAGK,CAAO,KAAKP,CAAG,IAAMO,CACjD,CAsBO,SAASb,EACde,EACAR,EACU,CACV,OAAOQ,EAAU,IAAI,CAAC,CAACV,EAAMC,CAAG,IAAMP,EAAKM,EAAMC,EAAKC,CAAO,CAAC,CAChE",
-  "names": ["links_exports", "__export", "link", "links", "__toCommonJS", "import_yoctocolors_cjs", "import_context", "import_utils", "text", "url", "options", "opts", "theme", "linkColor", "colors", "yoctocolorsCjs", "colored", "colorMethod", "linkSpecs"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,6BAA2B;AAE3B,qBAAyB;AACzB,mBAA6B;AA8CtB,SAAS,KAAK,MAAc,KAAa,SAA+B;AAC7E,QAAM,OAAO,EAAE,WAAW,MAAM,UAAU,OAAO,GAAG,QAAQ;AAG5D,QAAM,QACJ,OAAO,KAAK,UAAU,WAClB,QAAQ,kBAAkB,EAAE,OAAO,KAAK,KAAK,IAC5C,KAAK,aAAS,yBAAS;AAG9B,QAAM,gBAAY,2BAAa,MAAM,OAAO,MAAM,MAAM,MAAM;AAI9D,QAAM,SAAS,uBAAAA;AACf,MAAI;AACJ,MAAI,OAAO,cAAc,YAAY,cAAc,WAAW;AAE5D,UAAM,cAAc,OAAO,SAAsB;AACjD,cAAU,cAAc,YAAY,IAAI,IAAI,OAAO,KAAK,IAAI;AAAA,EAC9D,WAAW,MAAM,QAAQ,SAAS,GAAG;AAGnC,cAAU,OAAO,KAAK,IAAI;AAAA,EAC5B,OAAO;AACL,cAAU,OAAO,KAAK,IAAI;AAAA,EAC5B;AAGA,SAAO,KAAK,WAAW,GAAG,OAAO,KAAK,GAAG,MAAM;AACjD;AAsBO,SAAS,MACd,WACA,SACU;AACV,SAAO,UAAU,IAAI,CAAC,CAAC,MAAM,GAAG,MAAM,KAAK,MAAM,KAAK,OAAO,CAAC;AAChE;",
+  "names": ["yoctocolorsCjs"]
 }