filemayor 2.1.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

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * 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 environment variables only.
+ *
+ * Supported backends:
+ *   macOS   → security (Keychain Services)
+ *   Windows → PowerShell CredentialManager
+ *   Linux   → secret-tool (freedesktop Secret Service)
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const SERVICE_NAME = 'FileMayor';
+
+// ─── Platform-Specific Implementations ───────────────────────────
+
+function _saveSecret_darwin(key, value) {
+    execFileSync('security', [
+        'add-generic-password',
+        '-a', SERVICE_NAME,
+        '-s', key,
+        '-w', value,
+        '-U',
+    ], { stdio: 'ignore' });
+}
+
+function _getSecret_darwin(key) {
+    return execFileSync('security', [
+        'find-generic-password',
+        '-a', SERVICE_NAME,
+        '-s', key,
+        '-w',
+    ], { encoding: 'utf8' }).trim();
+}
+
+function _deleteSecret_darwin(key) {
+    execFileSync('security', [
+        'delete-generic-password',
+        '-a', SERVICE_NAME,
+        '-s', key,
+    ], { stdio: 'ignore' });
+}
+
+function _saveSecret_win32(key, value) {
+    // 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) {
+    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 execFileSync('powershell', [
+            '-NoProfile', '-NonInteractive', '-Command', scriptBlock,
+        ], { encoding: 'utf8' }).trim();
+    } catch {
+        return null;
+    }
+}
+
+function _saveSecret_linux(key, value) {
+    // 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 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} 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);
+            return true;
+        } catch (err) {
+            console.warn(`[Vault] Could not save to system keychain: ${err.message}`);
+            return false;
+        }
+    },
+
+    /**
+     * 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);
+            else if (process.platform === 'win32') {
+                const val = _getSecret_win32(key);
+                if (val) return val;
+            }
+            else return _getSecret_linux(key);
+        } catch { /* Keychain not available or key not found */ }
+
+        // Priority 2: Environment Variable
+        if (process.env[key]) return process.env[key];
+
+        return null;
+    },
+
+    /**
+     * 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);
+            else if (process.platform === 'linux') {
+                execFileSync('secret-tool', [
+                    'clear', 'service', SERVICE_NAME, 'key', key,
+                ], { stdio: 'ignore' });
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    },
+
+    /**
+     * 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;