lsh-framework 1.1.0 → 1.2.1

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

@@ -6,6 +6,7 @@ import SecretsManager from '../../lib/secrets-manager.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
+import { getGitRepoInfo } from '../../lib/git-utils.js';
 export async function init_secrets(program) {
     // Push secrets to cloud
     program
@@ -50,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);
@@ -80,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;
@@ -110,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();
@@ -129,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
@@ -272,13 +297,113 @@ API_KEY=
             process.exit(1);
         }
     });
+    // Info command - show relevant context information
+    program
+        .command('info')
+        .description('Show current directory context and tracked environment')
+        .option('-f, --file <path>', 'Path to .env file', '.env')
+        .option('-e, --env <name>', 'Environment name', 'dev')
+        .action(async (options) => {
+        try {
+            const gitInfo = getGitRepoInfo();
+            const manager = new SecretsManager();
+            const envPath = path.resolve(options.file);
+            console.log('\n📍 Current Directory Context\n');
+            // Git Repository Info
+            if (gitInfo.isGitRepo) {
+                console.log('📁 Git Repository:');
+                console.log(`   Root: ${gitInfo.rootPath || 'unknown'}`);
+                console.log(`   Name: ${gitInfo.repoName || 'unknown'}`);
+                if (gitInfo.currentBranch) {
+                    console.log(`   Branch: ${gitInfo.currentBranch}`);
+                }
+                if (gitInfo.remoteUrl) {
+                    console.log(`   Remote: ${gitInfo.remoteUrl}`);
+                }
+            }
+            else {
+                console.log('📁 Not in a git repository');
+            }
+            console.log('');
+            // Environment Tracking
+            console.log('🔐 Environment Tracking:');
+            // Show the effective environment name used for cloud storage
+            const effectiveEnv = gitInfo.repoName
+                ? `${gitInfo.repoName}_${options.env}`
+                : options.env;
+            console.log(`   Base environment: ${options.env}`);
+            console.log(`   Cloud storage name: ${effectiveEnv}`);
+            if (gitInfo.repoName) {
+                console.log(`   Namespace: ${gitInfo.repoName}`);
+                console.log('   ℹ️  Repo-based isolation enabled');
+            }
+            else {
+                console.log('   Namespace: (none - not in git repo)');
+                console.log('   ⚠️  No isolation - shared environment name');
+            }
+            console.log('');
+            // Local File Status
+            console.log('📄 Local .env File:');
+            if (fs.existsSync(envPath)) {
+                const content = fs.readFileSync(envPath, 'utf8');
+                const lines = content.split('\n').filter(line => {
+                    const trimmed = line.trim();
+                    return trimmed && !trimmed.startsWith('#') && trimmed.includes('=');
+                });
+                console.log(`   Path: ${envPath}`);
+                console.log(`   Keys: ${lines.length}`);
+                console.log(`   Size: ${Math.round(content.length / 1024 * 10) / 10} KB`);
+                // Check for encryption key
+                const hasKey = content.includes('LSH_SECRETS_KEY=');
+                console.log(`   Has encryption key: ${hasKey ? '✅' : '❌'}`);
+            }
+            else {
+                console.log(`   Path: ${envPath}`);
+                console.log('   Status: ❌ Not found');
+            }
+            console.log('');
+            // Cloud Status
+            console.log('☁️  Cloud Storage:');
+            try {
+                const status = await manager.status(options.file, options.env);
+                if (status.cloudExists) {
+                    console.log(`   Environment: ${effectiveEnv}`);
+                    console.log(`   Keys stored: ${status.cloudKeys}`);
+                    console.log(`   Last updated: ${status.cloudModified ? new Date(status.cloudModified).toLocaleString() : 'unknown'}`);
+                    if (status.keyMatches !== undefined) {
+                        console.log(`   Key matches: ${status.keyMatches ? '✅' : '❌ MISMATCH'}`);
+                    }
+                }
+                else {
+                    console.log(`   Environment: ${effectiveEnv}`);
+                    console.log('   Status: ❌ Not synced yet');
+                }
+            }
+            catch (_error) {
+                console.log('   Status: ⚠️  Unable to check (Supabase not configured)');
+            }
+            console.log('');
+            // Quick Actions
+            console.log('💡 Quick Actions:');
+            console.log(`   Push:  lsh push --env ${options.env}`);
+            console.log(`   Pull:  lsh pull --env ${options.env}`);
+            console.log(`   Sync:  lsh sync --env ${options.env}`);
+            console.log('');
+        }
+        catch (error) {
+            const err = error;
+            console.error('❌ Failed to get info:', err.message);
+            process.exit(1);
+        }
+    });
     // Get a specific secret value
     program
         .command('get [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')
         .action(async (key, options) => {
         try {
             const envPath = path.resolve(options.file);
@@ -306,20 +431,19 @@ API_KEY=
                         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}`);
-                    }
+                // 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