filemayor 3.6.0 → 4.0.5

package/core/telemetry.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const PING_URL = 'https://filemayor.com/api/ping';
+const STATE_FILE = path.join(os.homedir(), '.filemayor-telemetry.json');
+
+// Fire-and-forget anonymous ping.
+// Sends: version, OS platform, CPU arch, and top-level command name.
+// Never sends: file names, paths, sizes, contents, or any PII.
+// Opt-out: set FILEMAYOR_NO_TELEMETRY=1 in environment.
+// Fires at most once per version (tracked in ~/.filemayor-telemetry.json).
+function ping(version, cmd) {
+    if (process.env.FILEMAYOR_NO_TELEMETRY === '1') return;
+    if (process.env.CI) return;
+
+    try {
+        const state = readState();
+        if (state.pinged && state.pinged.includes(version)) return;
+
+        const payload = JSON.stringify({
+            v: version,
+            os: os.platform(),
+            arch: os.arch(),
+            cmd: cmd || 'unknown',
+        });
+
+        // Fire over https using built-in https module — no extra deps
+        const https = require('https');
+        const url = new URL(PING_URL);
+        const req = https.request({
+            hostname: url.hostname,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+                'User-Agent': `filemayor-cli/${version}`,
+            },
+            timeout: 3000,
+        });
+
+        req.on('error', () => {}); // swallow all errors — telemetry must never crash the CLI
+        req.on('timeout', () => req.destroy());
+        req.end(payload);
+
+        markPinged(state, version);
+    } catch {
+        // intentionally silent
+    }
+}
+
+function readState() {
+    try {
+        return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    } catch {
+        return { pinged: [] };
+    }
+}
+
+function markPinged(state, version) {
+    try {
+        const pinged = Array.isArray(state.pinged) ? state.pinged : [];
+        pinged.push(version);
+        // Keep only last 20 versions to bound file size
+        fs.writeFileSync(STATE_FILE, JSON.stringify({ pinged: pinged.slice(-20) }), 'utf-8');
+    } catch {
+        // intentionally silent
+    }
+}
+
+module.exports = { ping };

package/core/vault.js

@@ -3,21 +3,20 @@
 /**
  * ═══════════════════════════════════════════════════════════════════
  * FILEMAYOR CORE — VAULT (ZERO-DEPENDENCY SECRET MANAGER)
- * 
+ *
  * Uses the OS-native credential store to keep API keys out of
- * the filesystem entirely. Falls back to .env / environment
- * variables if the system keychain is unavailable.
- * 
+ * the filesystem entirely. Falls back to environment variables only.
+ *
  * Supported backends:
  *   macOS   → security (Keychain Services)
- *   Windows → cmdkey / PowerShell CredentialManager
+ *   Windows → PowerShell CredentialManager
  *   Linux   → secret-tool (freedesktop Secret Service)
  * ═══════════════════════════════════════════════════════════════════
  */
 
 'use strict';
 
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
@@ -26,72 +25,96 @@ const SERVICE_NAME = 'FileMayor';
 // ─── Platform-Specific Implementations ───────────────────────────
 
 function _saveSecret_darwin(key, value) {
-    // -U flag updates if already exists
-    execSync(
-        `security add-generic-password -a "${SERVICE_NAME}" -s "${key}" -w "${value}" -U`,
-        { stdio: 'ignore' }
-    );
+    execFileSync('security', [
+        'add-generic-password',
+        '-a', SERVICE_NAME,
+        '-s', key,
+        '-w', value,
+        '-U',
+    ], { stdio: 'ignore' });
 }
 
 function _getSecret_darwin(key) {
-    return execSync(
-        `security find-generic-password -a "${SERVICE_NAME}" -s "${key}" -w`,
-        { encoding: 'utf8' }
-    ).trim();
+    return execFileSync('security', [
+        'find-generic-password',
+        '-a', SERVICE_NAME,
+        '-s', key,
+        '-w',
+    ], { encoding: 'utf8' }).trim();
 }
 
 function _deleteSecret_darwin(key) {
-    execSync(
-        `security delete-generic-password -a "${SERVICE_NAME}" -s "${key}"`,
-        { stdio: 'ignore' }
-    );
+    execFileSync('security', [
+        'delete-generic-password',
+        '-a', SERVICE_NAME,
+        '-s', key,
+    ], { stdio: 'ignore' });
 }
 
 function _saveSecret_win32(key, value) {
-    // Use PowerShell to store in Windows Credential Manager
-    const cmd = `powershell -Command "cmdkey /generic:${SERVICE_NAME}_${key} /user:${key} /pass:${value}"`;
-    execSync(cmd, { stdio: 'ignore' });
+    // Pass the secret value via an environment variable to avoid it
+    // appearing in the command string or the process table.
+    const scriptBlock = `
+$target = "${SERVICE_NAME}_${key.replace(/[^A-Za-z0-9_-]/g, '_')}"
+$user   = "${key.replace(/[^A-Za-z0-9_-]/g, '_')}"
+$pass   = $env:FM_VAULT_VALUE
+cmdkey /generic:$target /user:$user /pass:$pass | Out-Null
+`.trim();
+    execFileSync('powershell', [
+        '-NoProfile', '-NonInteractive', '-Command', scriptBlock,
+    ], {
+        stdio: 'ignore',
+        env: { ...process.env, FM_VAULT_VALUE: value },
+    });
 }
 
 function _getSecret_win32(key) {
-    // Use PowerShell to retrieve from Windows Credential Manager
-    const cmd = `powershell -Command "(cmdkey /list:${SERVICE_NAME}_${key}) -match 'User' | Out-Null; $cred = Get-StoredCredential -Target ${SERVICE_NAME}_${key}; if($cred){$cred.GetNetworkCredential().Password}else{throw 'Not found'}"`;
+    const safeKey = key.replace(/[^A-Za-z0-9_-]/g, '_');
+    const target  = `${SERVICE_NAME}_${safeKey}`;
+    const scriptBlock =
+        `$c = Get-StoredCredential -Target '${target}'; ` +
+        `if ($c) { $c.GetNetworkCredential().Password } else { exit 1 }`;
     try {
-        return execSync(cmd, { encoding: 'utf8' }).trim();
+        return execFileSync('powershell', [
+            '-NoProfile', '-NonInteractive', '-Command', scriptBlock,
+        ], { encoding: 'utf8' }).trim();
     } catch {
-        // Fallback: try simpler cmdkey parsing
         return null;
     }
 }
 
 function _saveSecret_linux(key, value) {
-    execSync(
-        `echo "${value}" | secret-tool store --label="${SERVICE_NAME} ${key}" service "${SERVICE_NAME}" key "${key}"`,
-        { stdio: 'ignore' }
-    );
+    // Pass the secret via stdin so it never appears in the process table.
+    execFileSync('secret-tool', [
+        'store',
+        '--label', `${SERVICE_NAME} ${key}`,
+        'service', SERVICE_NAME,
+        'key', key,
+    ], { input: value + '\n', stdio: ['pipe', 'ignore', 'ignore'] });
 }
 
 function _getSecret_linux(key) {
-    return execSync(
-        `secret-tool lookup service "${SERVICE_NAME}" key "${key}"`,
-        { encoding: 'utf8' }
-    ).trim();
+    return execFileSync('secret-tool', [
+        'lookup',
+        'service', SERVICE_NAME,
+        'key', key,
+    ], { encoding: 'utf8' }).trim();
 }
 
 // ─── The Vault ────────────────────────────────────────────────────
 
 const Vault = {
     /**
-     * Save a secret to the system keychain
-     * @param {string} key - Secret name (e.g., 'GEMINI_API_KEY')
-     * @param {string} value - Secret value
-     * @returns {boolean} Success
+     * Save a secret to the system keychain.
+     * @param {string} key   Secret name (e.g. 'GEMINI_API_KEY')
+     * @param {string} value Secret value
+     * @returns {boolean} true on success
      */
     saveSecret(key, value) {
         try {
-            if (process.platform === 'darwin') _saveSecret_darwin(key, value);
-            else if (process.platform === 'win32') _saveSecret_win32(key, value);
-            else _saveSecret_linux(key, value);
+            if (process.platform === 'darwin')      _saveSecret_darwin(key, value);
+            else if (process.platform === 'win32')  _saveSecret_win32(key, value);
+            else                                     _saveSecret_linux(key, value);
             return true;
         } catch (err) {
             console.warn(`[Vault] Could not save to system keychain: ${err.message}`);
@@ -100,14 +123,17 @@ const Vault = {
     },
 
     /**
-     * Retrieve a secret — checks System Keychain → ENV → .env file
-     * @param {string} key - Secret name
-     * @returns {string|null} The secret value, or null
+     * Retrieve a secret — checks System Keychain → ENV.
+     * The .env plaintext fallback has been removed. Set secrets via
+     * `filemayor config set KEY value` (stores in keychain) or
+     * export them as shell environment variables before starting.
+     * @param {string} key Secret name
+     * @returns {string|null}
      */
     getSecret(key) {
         // Priority 1: System Keychain (most secure)
         try {
-            if (process.platform === 'darwin') return _getSecret_darwin(key);
+            if (process.platform === 'darwin')     return _getSecret_darwin(key);
             else if (process.platform === 'win32') {
                 const val = _getSecret_win32(key);
                 if (val) return val;
@@ -118,34 +144,22 @@ const Vault = {
         // Priority 2: Environment Variable
         if (process.env[key]) return process.env[key];
 
-        // Priority 3: .env file (least secure, but common)
-        try {
-            const envPath = path.join(process.cwd(), '.env');
-            if (fs.existsSync(envPath)) {
-                const envFile = fs.readFileSync(envPath, 'utf-8');
-                for (const line of envFile.split('\n')) {
-                    const trimmed = line.trim();
-                    if (trimmed.startsWith('#') || !trimmed) continue;
-                    const [k, ...vals] = trimmed.split('=');
-                    if (k.trim() === key && vals.length) {
-                        return vals.join('=').trim();
-                    }
-                }
-            }
-        } catch { /* .env not available */ }
-
         return null;
     },
 
     /**
-     * Delete a secret from the system keychain
-     * @param {string} key - Secret name
-     * @returns {boolean} Success
+     * Delete a secret from the system keychain.
+     * @param {string} key Secret name
+     * @returns {boolean} true on success
      */
     deleteSecret(key) {
         try {
-            if (process.platform === 'darwin') _deleteSecret_darwin(key);
-            // Windows and Linux deletion handled differently
+            if (process.platform === 'darwin')       _deleteSecret_darwin(key);
+            else if (process.platform === 'linux') {
+                execFileSync('secret-tool', [
+                    'clear', 'service', SERVICE_NAME, 'key', key,
+                ], { stdio: 'ignore' });
+            }
             return true;
         } catch {
             return false;
@@ -153,13 +167,13 @@ const Vault = {
     },
 
     /**
-     * Check if a secret exists anywhere in the priority chain
-     * @param {string} key 
+     * Check if a secret exists anywhere in the priority chain.
+     * @param {string} key
      * @returns {boolean}
      */
     hasSecret(key) {
         return Vault.getSecret(key) !== null;
-    }
+    },
 };
 
 module.exports = Vault;