lsh-framework 1.2.0 → 1.3.0

package/dist/lib/platform-utils.js

@@ -0,0 +1,211 @@
+/**
+ * Platform Utilities
+ * Cross-platform path and environment handling for Windows, macOS, and Linux
+ */
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * Get platform-specific paths
+ * Handles differences between Windows, macOS, and Linux
+ */
+export function getPlatformPaths(appName = 'lsh') {
+    const isWindows = process.platform === 'win32';
+    const isMac = process.platform === 'darwin';
+    // Temporary directory
+    const tmpDir = os.tmpdir();
+    // Home directory
+    const homeDir = os.homedir();
+    // Username
+    const user = os.userInfo().username;
+    // Application-specific temporary file paths
+    const pidFile = path.join(tmpDir, `${appName}-daemon-${user}.pid`);
+    const logFile = path.join(tmpDir, `${appName}-daemon-${user}.log`);
+    // Socket/IPC path (platform-specific)
+    // Windows uses Named Pipes, Unix systems use Unix Domain Sockets
+    const socketPath = isWindows
+        ? `\\\\.\\pipe\\${appName}-daemon-${user}`
+        : path.join(tmpDir, `${appName}-daemon-${user}.sock`);
+    // Configuration directory
+    // Windows: %APPDATA%\lsh
+    // macOS: ~/Library/Application Support/lsh
+    // Linux: ~/.config/lsh
+    let configDir;
+    if (isWindows) {
+        configDir = path.join(process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming'), appName);
+    }
+    else if (isMac) {
+        configDir = path.join(homeDir, 'Library', 'Application Support', appName);
+    }
+    else {
+        configDir = path.join(homeDir, '.config', appName);
+    }
+    // Data directory
+    // Windows: %LOCALAPPDATA%\lsh
+    // macOS: ~/Library/Application Support/lsh
+    // Linux: ~/.local/share/lsh
+    let dataDir;
+    if (isWindows) {
+        dataDir = path.join(process.env.LOCALAPPDATA || path.join(homeDir, 'AppData', 'Local'), appName);
+    }
+    else if (isMac) {
+        dataDir = path.join(homeDir, 'Library', 'Application Support', appName);
+    }
+    else {
+        dataDir = path.join(homeDir, '.local', 'share', appName);
+    }
+    return {
+        tmpDir,
+        homeDir,
+        user,
+        pidFile,
+        logFile,
+        socketPath,
+        configDir,
+        dataDir,
+    };
+}
+/**
+ * Normalize path for current platform
+ */
+export function normalizePath(inputPath) {
+    return path.normalize(inputPath);
+}
+/**
+ * Check if running on Windows
+ */
+export function isWindows() {
+    return process.platform === 'win32';
+}
+/**
+ * Check if running on macOS
+ */
+export function isMacOS() {
+    return process.platform === 'darwin';
+}
+/**
+ * Check if running on Linux
+ */
+export function isLinux() {
+    return process.platform === 'linux';
+}
+/**
+ * Get platform name
+ */
+export function getPlatformName() {
+    const platform = process.platform;
+    switch (platform) {
+        case 'win32':
+            return 'Windows';
+        case 'darwin':
+            return 'macOS';
+        case 'linux':
+            return 'Linux';
+        default:
+            return platform;
+    }
+}
+/**
+ * Get environment variable with fallback
+ * Handles Windows vs Unix differences (e.g., HOME vs USERPROFILE)
+ */
+export function getEnvVar(unixVar, windowsVar) {
+    if (isWindows() && windowsVar) {
+        return process.env[windowsVar] || process.env[unixVar];
+    }
+    return process.env[unixVar];
+}
+/**
+ * Ensure directory exists, create if needed (cross-platform)
+ */
+export async function ensureDir(dirPath) {
+    const fs = await import('fs/promises');
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+    catch (error) {
+        // Ignore if directory already exists
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+}
+/**
+ * Get shell executable path for current platform
+ */
+export function getDefaultShell() {
+    if (isWindows()) {
+        return process.env.COMSPEC || 'cmd.exe';
+    }
+    return process.env.SHELL || '/bin/sh';
+}
+/**
+ * Get path separator for current platform
+ */
+export function getPathSeparator() {
+    return path.delimiter; // : on Unix, ; on Windows
+}
+/**
+ * Join paths with platform-appropriate separator
+ */
+export function joinPaths(...paths) {
+    return path.join(...paths);
+}
+/**
+ * Convert Unix-style path to platform path
+ */
+export function toPlatformPath(unixPath) {
+    if (isWindows()) {
+        return unixPath.replace(/\//g, '\\');
+    }
+    return unixPath;
+}
+/**
+ * Convert platform path to Unix-style path
+ */
+export function toUnixPath(platformPath) {
+    return platformPath.replace(/\\/g, '/');
+}
+/**
+ * Get executable extension for current platform
+ */
+export function getExecutableExtension() {
+    return isWindows() ? '.exe' : '';
+}
+/**
+ * Check if a path is absolute (cross-platform)
+ */
+export function isAbsolutePath(inputPath) {
+    return path.isAbsolute(inputPath);
+}
+/**
+ * Resolve path relative to home directory
+ */
+export function resolveHomePath(relativePath) {
+    if (relativePath.startsWith('~')) {
+        const homeDir = os.homedir();
+        return path.join(homeDir, relativePath.slice(1));
+    }
+    return relativePath;
+}
+/**
+ * Get platform-specific line ending
+ */
+export function getLineEnding() {
+    return isWindows() ? '\r\n' : '\n';
+}
+/**
+ * Get comprehensive platform information
+ */
+export function getPlatformInfo() {
+    const paths = getPlatformPaths();
+    return {
+        platform: process.platform,
+        platformName: getPlatformName(),
+        arch: process.arch,
+        release: os.release(),
+        nodeVersion: process.version,
+        homeDir: paths.homeDir,
+        tmpDir: paths.tmpDir,
+        user: paths.user,
+    };
+}

package/dist/lib/secrets-manager.js

@@ -340,7 +340,7 @@ export class SecretsManager {
     /**
      * Show secrets (masked)
      */
-    async show(environment = 'dev') {
+    async show(environment = 'dev', format = 'env') {
         const jobs = await this.persistence.getActiveJobs();
         const secretsJobs = jobs
             .filter(j => j.command === 'secrets_sync' && j.job_id.includes(environment))
@@ -355,6 +355,16 @@ export class SecretsManager {
         }
         const decrypted = this.decrypt(latestSecret.output);
         const env = this.parseEnvFile(decrypted);
+        // Convert to array format for formatSecrets
+        const secrets = Object.entries(env).map(([key, value]) => ({ key, value }));
+        // Use format utilities if not default env format
+        if (format !== 'env') {
+            const { formatSecrets } = await import('./format-utils.js');
+            const output = formatSecrets(secrets, format, false); // No masking for structured formats
+            console.log(output);
+            return;
+        }
+        // Default env format with masking (legacy behavior)
         console.log(`\n📦 Secrets for ${environment} (${Object.keys(env).length} total):\n`);
         for (const [key, value] of Object.entries(env)) {
             const masked = value.length > 4

package/dist/lib/string-utils.js

@@ -0,0 +1,128 @@
+/**
+ * String Utilities
+ *
+ * Helper functions for working with strings, especially for formatting
+ * constant template strings with dynamic values.
+ */
+/**
+ * Format a template string by replacing ${varName} placeholders with values
+ *
+ * @param template - Template string with ${varName} placeholders
+ * @param vars - Object mapping variable names to values
+ * @returns Formatted string
+ *
+ * @example
+ * ```typescript
+ * import { ERRORS } from '../constants/index.js';
+ * import { formatMessage } from './string-utils.js';
+ *
+ * const error = formatMessage(ERRORS.JOB_NOT_FOUND, { jobId: '12345' });
+ * // Returns: "Job 12345 not found"
+ * ```
+ */
+export function formatMessage(template, vars) {
+    let result = template;
+    // Sort keys by length (longest first) to prevent overlapping variable name issues
+    // Example: if we have both 'id' and 'jobId', we want to replace 'jobId' first
+    const sortedEntries = Object.entries(vars).sort((a, b) => b[0].length - a[0].length);
+    for (const [key, value] of sortedEntries) {
+        const placeholder = `\${${key}}`;
+        // Use replaceAll with literal string to avoid regex escaping complexity
+        result = result.replaceAll(placeholder, String(value));
+    }
+    return result;
+}
+/**
+ * Format a path template by replacing ${VAR} placeholders with environment variables
+ *
+ * @param pathTemplate - Path template with ${VAR} placeholders
+ * @param fallbacks - Optional fallback values for variables
+ * @returns Formatted path
+ *
+ * @example
+ * ```typescript
+ * import { PATHS } from '../constants/index.js';
+ * import { formatPath } from './string-utils.js';
+ *
+ * const socketPath = formatPath(PATHS.DAEMON_SOCKET_TEMPLATE, { USER: 'default' });
+ * // Returns: "/tmp/lsh-job-daemon-johndoe.sock" (if USER env var is johndoe)
+ * // Or: "/tmp/lsh-job-daemon-default.sock" (if USER env var is not set)
+ * ```
+ */
+export function formatPath(pathTemplate, fallbacks = {}) {
+    let result = pathTemplate;
+    const pattern = /\$\{([^}]+)\}/g;
+    const matches = Array.from(pathTemplate.matchAll(pattern));
+    // Process matches to collect unique variable names and their values
+    const replacements = new Map();
+    for (const match of matches) {
+        const varName = match[1];
+        if (!replacements.has(match[0])) {
+            const value = process.env[varName] || fallbacks[varName] || '';
+            replacements.set(match[0], value);
+        }
+    }
+    // Replace all occurrences of each placeholder
+    for (const [placeholder, value] of replacements) {
+        result = result.replaceAll(placeholder, value);
+    }
+    return result;
+}
+/**
+ * Truncate a string to a maximum length, adding ellipsis if needed
+ *
+ * @param str - String to truncate
+ * @param maxLength - Maximum length (default: 50)
+ * @param ellipsis - Ellipsis to append (default: '...')
+ * @returns Truncated string
+ *
+ * @example
+ * ```typescript
+ * truncate('This is a very long error message', 20);
+ * // Returns: "This is a very lo..."
+ * ```
+ */
+export function truncate(str, maxLength = 50, ellipsis = '...') {
+    // Validate that maxLength is greater than ellipsis length
+    if (maxLength < ellipsis.length) {
+        throw new Error(`maxLength (${maxLength}) must be greater than or equal to ellipsis length (${ellipsis.length})`);
+    }
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.substring(0, maxLength - ellipsis.length) + ellipsis;
+}
+/**
+ * Escape special characters in a string for use in a regular expression
+ *
+ * @param str - String to escape
+ * @returns Escaped string
+ *
+ * @example
+ * ```typescript
+ * escapeRegex('test.file');
+ * // Returns: "test\\.file"
+ * ```
+ */
+export function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Pluralize a word based on count
+ *
+ * @param count - Count to check
+ * @param singular - Singular form
+ * @param plural - Plural form (default: singular + 's')
+ * @returns Pluralized string with count
+ *
+ * @example
+ * ```typescript
+ * pluralize(1, 'job');  // "1 job"
+ * pluralize(5, 'job');  // "5 jobs"
+ * pluralize(2, 'query', 'queries');  // "2 queries"
+ * ```
+ */
+export function pluralize(count, singular, plural) {
+    const pluralForm = plural || `${singular}s`;
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}

package/dist/services/daemon/daemon-registrar.js

@@ -6,6 +6,7 @@ import { BaseCommandRegistrar } from '../../lib/base-command-registrar.js';
 import * as fs from 'fs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { getPlatformPaths } from '../../lib/platform-utils.js';
 const execAsync = promisify(exec);
 export class DaemonCommandRegistrar extends BaseCommandRegistrar {
     constructor() {
@@ -43,8 +44,8 @@ export class DaemonCommandRegistrar extends BaseCommandRegistrar {
             description: 'Start the daemon',
             action: async () => {
                 const { spawn } = await import('child_process');
-                const socketPath = `/tmp/lsh-job-daemon-${process.env.USER || 'user'}.sock`;
-                const daemonProcess = spawn('node', ['dist/daemon/lshd.js', 'start', socketPath], {
+                const platformPaths = getPlatformPaths('lsh');
+                const daemonProcess = spawn('node', ['dist/daemon/lshd.js', 'start', platformPaths.socketPath], {
                     detached: true,
                     stdio: 'ignore'
                 });

package/dist/services/secrets/secrets.js

@@ -51,6 +51,8 @@ export async function init_secrets(program) {
         .description('List secrets in the current local .env file')
         .option('-f, --file <path>', 'Path to .env file', '.env')
         .option('--keys-only', 'Show only keys, not values')
+        .option('--format <type>', 'Output format: env, json, yaml, toml, export', 'env')
+        .option('--no-mask', 'Show full values (default: auto based on format)')
         .action(async (options) => {
         try {
             const envPath = path.resolve(options.file);
@@ -81,24 +83,38 @@ export async function init_secrets(program) {
                 console.log('No secrets found in .env file');
                 return;
             }
-            console.log(`\n📋 Secrets in ${options.file}:\n`);
-            for (const { key, value } of secrets) {
-                if (options.keysOnly) {
+            // Handle keys-only mode
+            if (options.keysOnly) {
+                console.log(`\n📋 Keys in ${options.file}:\n`);
+                for (const { key } of secrets) {
                     console.log(`  ${key}`);
                 }
-                else {
-                    // Mask the value but show first/last 3 chars if long enough
-                    let maskedValue = value;
-                    if (value.length > 8) {
-                        maskedValue = `${value.substring(0, 3)}${'*'.repeat(value.length - 6)}${value.substring(value.length - 3)}`;
-                    }
-                    else if (value.length > 0) {
-                        maskedValue = '*'.repeat(value.length);
-                    }
-                    console.log(`  ${key}=${maskedValue}`);
-                }
+                console.log(`\n  Total: ${secrets.length} keys\n`);
+                return;
+            }
+            // Handle format output
+            const format = options.format.toLowerCase();
+            const validFormats = ['env', 'json', 'yaml', 'toml', 'export'];
+            if (!validFormats.includes(format)) {
+                console.error(`❌ Invalid format: ${format}`);
+                console.log(`Valid formats: ${validFormats.join(', ')}`);
+                process.exit(1);
+            }
+            // Import format utilities dynamically
+            const { formatSecrets } = await import('../../lib/format-utils.js');
+            // Determine masking behavior
+            const shouldMask = options.mask !== false ? undefined : false;
+            const output = formatSecrets(secrets, format, shouldMask);
+            // Only show header for default env format
+            if (format === 'env') {
+                console.log(`\n📋 Secrets in ${options.file}:\n`);
+                console.log(output);
+                console.log(`\n  Total: ${secrets.length} secrets\n`);
+            }
+            else {
+                // For structured formats, output directly (no decoration)
+                console.log(output);
             }
-            console.log(`\n  Total: ${secrets.length} secrets\n`);
         }
         catch (error) {
             const err = error;
@@ -111,6 +127,7 @@ export async function init_secrets(program) {
         .command('env [environment]')
         .description('List all stored environments or show secrets for specific environment')
         .option('--all-files', 'List all tracked .env files across environments')
+        .option('--format <type>', 'Output format: env, json, yaml, toml, export', 'env')
         .action(async (environment, options) => {
         try {
             const manager = new SecretsManager();
@@ -130,7 +147,14 @@ export async function init_secrets(program) {
             }
             // If environment specified, show secrets for that environment
             if (environment) {
-                await manager.show(environment);
+                const format = options.format.toLowerCase();
+                const validFormats = ['env', 'json', 'yaml', 'toml', 'export'];
+                if (!validFormats.includes(format)) {
+                    console.error(`❌ Invalid format: ${format}`);
+                    console.log(`Valid formats: ${validFormats.join(', ')}`);
+                    process.exit(1);
+                }
+                await manager.show(environment, format);
                 return;
             }
             // Otherwise, list all environments
@@ -378,7 +402,9 @@ API_KEY=
         .description('Get a specific secret value from .env file, or all secrets with --all')
         .option('-f, --file <path>', 'Path to .env file', '.env')
         .option('--all', 'Get all secrets from the file')
-        .option('--export', 'Output in export format for shell evaluation')
+        .option('--export', 'Output in export format for shell evaluation (alias for --format export)')
+        .option('--format <type>', 'Output format: env, json, yaml, toml, export', 'env')
+        .option('--exact', 'Require exact key match (disable fuzzy matching)')
         .action(async (key, options) => {
         try {
             const envPath = path.resolve(options.file);
@@ -388,61 +414,95 @@ API_KEY=
             }
             const content = fs.readFileSync(envPath, 'utf8');
             const lines = content.split('\n');
-            // Handle --all flag
-            if (options.all) {
-                const secrets = [];
-                for (const line of lines) {
-                    if (line.trim().startsWith('#') || !line.trim())
-                        continue;
-                    const match = line.match(/^([^=]+)=(.*)$/);
-                    if (match) {
-                        const key = match[1].trim();
-                        let value = match[2].trim();
-                        // Remove quotes if present
-                        if ((value.startsWith('"') && value.endsWith('"')) ||
-                            (value.startsWith("'") && value.endsWith("'"))) {
-                            value = value.slice(1, -1);
-                        }
-                        secrets.push({ key, value });
-                    }
-                }
-                if (options.export) {
-                    // Output in export format for shell evaluation
-                    for (const { key, value } of secrets) {
-                        // Escape single quotes in value and wrap in single quotes
-                        const escapedValue = value.replace(/'/g, "'\\''");
-                        console.log(`export ${key}='${escapedValue}'`);
-                    }
-                }
-                else {
-                    // Output in KEY=VALUE format
-                    for (const { key, value } of secrets) {
-                        console.log(`${key}=${value}`);
-                    }
-                }
-                return;
-            }
-            // Handle single key lookup
-            if (!key) {
-                console.error('❌ Please provide a key or use --all flag');
-                process.exit(1);
-            }
+            // Parse all secrets from file
+            const secrets = [];
             for (const line of lines) {
                 if (line.trim().startsWith('#') || !line.trim())
                     continue;
                 const match = line.match(/^([^=]+)=(.*)$/);
-                if (match && match[1].trim() === key) {
+                if (match) {
+                    const key = match[1].trim();
                     let value = match[2].trim();
                     // Remove quotes if present
                     if ((value.startsWith('"') && value.endsWith('"')) ||
                         (value.startsWith("'") && value.endsWith("'"))) {
                         value = value.slice(1, -1);
                     }
-                    console.log(value);
+                    secrets.push({ key, value });
+                }
+            }
+            // Handle --all flag
+            if (options.all) {
+                // Handle format output
+                const format = options.export ? 'export' : options.format.toLowerCase();
+                const validFormats = ['env', 'json', 'yaml', 'toml', 'export'];
+                if (!validFormats.includes(format)) {
+                    console.error(`❌ Invalid format: ${format}`);
+                    console.log(`Valid formats: ${validFormats.join(', ')}`);
+                    process.exit(1);
+                }
+                // Import format utilities dynamically
+                const { formatSecrets } = await import('../../lib/format-utils.js');
+                // For get --all, always show full values (no masking)
+                const output = formatSecrets(secrets, format, false);
+                console.log(output);
+                return;
+            }
+            // Handle single key lookup
+            if (!key) {
+                console.error('❌ Please provide a key or use --all flag');
+                process.exit(1);
+            }
+            // Try exact match first
+            const exactMatch = secrets.find(s => s.key === key);
+            if (exactMatch) {
+                console.log(exactMatch.value);
+                return;
+            }
+            // If exact match enabled, don't do fuzzy matching
+            if (options.exact) {
+                console.error(`❌ Key '${key}' not found in ${options.file}`);
+                process.exit(1);
+            }
+            // Use fuzzy matching
+            const { findFuzzyMatches } = await import('../../lib/fuzzy-match.js');
+            const matches = findFuzzyMatches(key, secrets);
+            if (matches.length === 0) {
+                console.error(`❌ No matches found for '${key}' in ${options.file}`);
+                console.error('💡 Tip: Use --exact flag for exact matching only');
+                process.exit(1);
+            }
+            // If single match, return it
+            if (matches.length === 1) {
+                console.log(matches[0].value);
+                return;
+            }
+            // If best match score is significantly higher than second best (clear winner)
+            // then auto-select it
+            if (matches.length > 1) {
+                const bestScore = matches[0].score;
+                const secondBestScore = matches[1].score;
+                // If best match scores 700+ and is at least 2x better than second best,
+                // consider it a clear match
+                if (bestScore >= 700 && bestScore >= secondBestScore * 2) {
+                    console.log(matches[0].value);
                     return;
                 }
             }
-            console.error(`❌ Key '${key}' not found in ${options.file}`);
+            // Multiple matches - show all matches for user to choose
+            console.error(`🔍 Found ${matches.length} matches for '${key}':\n`);
+            for (const match of matches) {
+                // Mask value for display
+                const maskedValue = match.value.length > 4
+                    ? match.value.substring(0, 4) + '*'.repeat(Math.min(match.value.length - 4, 10))
+                    : '****';
+                console.error(`  ${match.key}=${maskedValue}`);
+            }
+            console.error('');
+            console.error('💡 Please specify the exact key name or use one of:');
+            for (const match of matches) {
+                console.error(`   lsh get ${match.key}`);
+            }
             process.exit(1);
         }
         catch (error) {