lsh-framework 1.2.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

@@ -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,8 @@ 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')
         .action(async (key, options) => {
         try {
             const envPath = path.resolve(options.file);
@@ -406,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lsh-framework",
-  "version": "1.2.0",
-  "description": "Encrypted secrets manager with automatic rotation, team sync, and multi-environment support. Built on a powerful shell with daemon scheduling and CI/CD integration.",
+  "version": "1.2.1",
+  "description": "Simple, cross-platform encrypted secrets manager with automatic sync and multi-environment support. Just run lsh sync and start managing your secrets.",
   "main": "dist/app.js",
   "bin": {
     "lsh": "./dist/cli.js"
@@ -16,24 +16,13 @@
   },
   "scripts": {
     "build": "tsc",
-    "compile-ts": "tsc -b",
-    "compile-nexe": "node build.js",
-    "build-bin": "npm run clean; npm run compile-ts; npm run compile-nexe",
-    "start": "node dist/app.js",
-    "start:pipeline": "npm run compile-ts && node dist/pipeline/pipeline-service.js",
     "watch": "tsc --watch",
     "test": "node --experimental-vm-modules ./node_modules/.bin/jest",
     "test:coverage": "node --experimental-vm-modules ./node_modules/.bin/jest --coverage",
-    "test:integration": "npm run test -- --testMatch=\"**/*.integration.test.(js|ts)\"",
     "clean": "rm -rf ./build; rm -rf ./bin; rm -rf ./dist",
-    "electron": "npm run compile-ts && electron src/electron/main.cjs",
-    "electron-dev": "NODE_ENV=development npm run electron",
-    "dashboard": "npm run electron",
-    "app": "npm run electron",
     "lint": "eslint src --ext .js,.ts,.tsx",
     "lint:fix": "eslint src --ext .js,.ts,.tsx --fix",
-    "typecheck": "tsc --noEmit",
-    "audit:security": "npm audit --audit-level moderate"
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "secrets-manager",
@@ -44,17 +33,11 @@
     "encryption",
     "credential-management",
     "team-sync",
-    "secrets-rotation",
     "multi-environment",
     "devops",
     "security",
-    "shell",
-    "automation",
-    "cron",
-    "daemon",
-    "job-scheduler",
-    "cicd",
-    "cli"
+    "cli",
+    "cross-platform"
   ],
   "engines": {
     "node": ">=20.18.0",
@@ -74,76 +57,29 @@
     "package.json"
   ],
   "dependencies": {
-    "@deck.gl/core": "^8.9.33",
-    "@inkjs/ui": "^1.0.0",
-    "@octokit/rest": "^20.1.0",
     "@supabase/supabase-js": "^2.57.4",
-    "@types/ink": "^2.0.3",
-    "@types/ioredis": "^4.28.10",
-    "@types/socket.io": "^3.0.1",
-    "@xstate/react": "^4.1.0",
-    "async": "^3.2.5",
-    "async-lock": "^1.4.0",
-    "axios": "^1.5.1",
-    "bcrypt": "^5.1.1",
     "chalk": "^5.3.0",
-    "cheerio": "^1.0.0-rc.12",
     "chokidar": "^3.6.0",
     "commander": "^10.0.1",
-    "cors": "^2.8.5",
-    "csv": "^6.3.5",
     "dotenv": "^16.4.5",
-    "express": "^5.1.0",
-    "fprint": "^2.0.1",
     "glob": "^10.3.12",
-    "gradstop": "^2.2.3",
-    "helmet": "^8.1.0",
-    "highlightjs": "^9.16.2",
-    "http-proxy-middleware": "^3.0.5",
-    "ink": "^4.4.1",
-    "ink-text-input": "^5.0.1",
     "inquirer": "^9.2.12",
-    "ioredis": "^5.8.0",
-    "jsonwebtoken": "^9.0.2",
-    "lodash": "^4.17.21",
-    "lsh-framework": "^0.8.2",
+    "js-yaml": "^4.1.0",
     "node-cron": "^3.0.3",
-    "node-fetch": "^3.3.2",
     "ora": "^8.0.1",
-    "path": "^0.12.7",
     "pg": "^8.16.3",
-    "react": "^18.2.0",
-    "repl": "^0.1.3",
-    "sendgrid": "^5.2.3",
-    "socket.io": "^4.8.1",
-    "uuid": "^10.0.0",
-    "xstate": "^5.9.1",
-    "zx": "^7.2.3"
+    "smol-toml": "^1.3.1",
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.23.2",
-    "@babel/preset-react": "^7.24.1",
-    "@types/async-lock": "^1.4.2",
     "@types/jest": "^30.0.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.12.7",
-    "@types/react": "^18.2.73",
-    "@types/request": "^2.48.12",
-    "@types/supertest": "^6.0.3",
     "@typescript-eslint/eslint-plugin": "^8.44.1",
     "@typescript-eslint/parser": "^8.44.1",
-    "babel-jest": "^29.7.0",
-    "electron": "^38.1.2",
     "eslint": "^9.36.0",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
     "jest": "^29.7.0",
-    "mocha": "^10.3.0",
-    "ncc": "^0.3.6",
-    "nexe": "^4.0.0-rc.2",
-    "nodemon": "^3.0.1",
-    "supertest": "^7.1.4",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.4.5",
-    "zapier-platform-core": "15.4.1"
+    "typescript": "^5.4.5"
   }
 }