minovative-mind-cli 2.2.4 → 2.3.0

package/dist/utils/credentialStore.js

@@ -0,0 +1,540 @@
+import { execFile } from 'node:child_process';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { debugLog } from './logger.js';
+// ─── Constants ───────────────────────────────────────────────────────
+const SERVICE_NAME = 'minovative-mind-cli';
+const ACCOUNT_NAME = 'default';
+const KEYCHAIN_LABEL = 'Minovative Mind CLI';
+/**
+ * Maximum time (ms) to wait for an OS keychain CLI call before falling back.
+ * Prevents indefinite hangs over SSH or headless sessions where the keychain
+ * may prompt for GUI interaction that will never arrive.
+ */
+const KEYCHAIN_TIMEOUT_MS = 3000;
+/** Encrypted fallback file path. */
+const ENCRYPTED_FILE = path.join(os.homedir(), '.minovative-mind-cli.enc');
+/** Machine-specific salt used for AES key derivation in fallback mode. */
+const SALT_FILE = path.join(os.homedir(), '.minovative-mind-cli-salt');
+/** Legacy plaintext file path (for migration). */
+export const LEGACY_CONFIG_FILE = path.join(os.homedir(), '.minovative-mind-cli.json');
+// ─── Backend Detection ───────────────────────────────────────────────
+let cachedBackend = null;
+/**
+ * Determines the best available credential storage backend for the current OS.
+ * Results are cached after the first successful probe.
+ */
+async function detectBackend() {
+    if (cachedBackend)
+        return cachedBackend;
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        if (await isCommandAvailable('security')) {
+            cachedBackend = 'keychain-macos';
+            debugLog('Credential store: using macOS Keychain');
+            return cachedBackend;
+        }
+    }
+    if (platform === 'linux') {
+        if (await isCommandAvailable('secret-tool')) {
+            cachedBackend = 'libsecret-linux';
+            debugLog('Credential store: using libsecret (secret-tool)');
+            return cachedBackend;
+        }
+    }
+    if (platform === 'win32') {
+        // DPAPI is always available on Windows via PowerShell
+        if (await isCommandAvailable('powershell')) {
+            cachedBackend = 'dpapi-windows';
+            debugLog('Credential store: using Windows DPAPI');
+            return cachedBackend;
+        }
+    }
+    cachedBackend = 'encrypted-file';
+    debugLog('Credential store: using AES-256-GCM encrypted file fallback');
+    return cachedBackend;
+}
+/**
+ * Executes a command with a timeout. If the command doesn't complete within
+ * the timeout, the child process is killed and the promise rejects.
+ * This prevents hangs in headless/SSH sessions where OS keychain tools
+ * might wait for GUI prompts that will never arrive.
+ */
+async function execWithTimeout(command, args, timeoutMs = KEYCHAIN_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const child = execFile(command, args, { timeout: timeoutMs }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve({ stdout: stdout, stderr: stderr });
+            }
+        });
+        // Belt-and-suspenders: kill if the built-in timeout doesn't fire
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new Error(`${command} timed out after ${timeoutMs}ms (possible GUI prompt in headless session)`));
+        }, timeoutMs + 500);
+        child.on('close', () => clearTimeout(timer));
+    });
+}
+/**
+ * Checks whether a given CLI command is available on PATH.
+ */
+async function isCommandAvailable(command) {
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        await execWithTimeout(which, [command], 2000);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── macOS Keychain ──────────────────────────────────────────────────
+async function macSave(json) {
+    try {
+        // -U flag updates the item if it already exists instead of erroring
+        await execWithTimeout('security', [
+            'add-generic-password',
+            '-a', ACCOUNT_NAME,
+            '-s', SERVICE_NAME,
+            '-l', KEYCHAIN_LABEL,
+            '-w', json,
+            '-U',
+        ]);
+    }
+    catch (err) {
+        throw new Error(`macOS Keychain save failed: ${err.message}`);
+    }
+}
+async function macLoad() {
+    try {
+        const { stdout } = await execWithTimeout('security', [
+            'find-generic-password',
+            '-a', ACCOUNT_NAME,
+            '-s', SERVICE_NAME,
+            '-w',
+        ]);
+        return stdout.trim();
+    }
+    catch {
+        // Item not found (exit code 44) or keychain locked
+        return null;
+    }
+}
+async function macClear() {
+    try {
+        await execWithTimeout('security', [
+            'delete-generic-password',
+            '-a', ACCOUNT_NAME,
+            '-s', SERVICE_NAME,
+        ]);
+    }
+    catch {
+        // Item not found — already cleared, ignore
+    }
+}
+// ─── Linux libsecret ────────────────────────────────────────────────
+async function linuxSave(json) {
+    try {
+        // secret-tool reads the secret value from stdin
+        const child = execFile('secret-tool', [
+            'store',
+            '--label', KEYCHAIN_LABEL,
+            'service', SERVICE_NAME,
+            'account', ACCOUNT_NAME,
+        ]);
+        if (child.stdin) {
+            child.stdin.write(json);
+            child.stdin.end();
+        }
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                child.kill('SIGTERM');
+                reject(new Error('secret-tool store timed out (possible missing DBus session)'));
+            }, KEYCHAIN_TIMEOUT_MS);
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`secret-tool store exited with code ${code}`));
+            });
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+    catch (err) {
+        throw new Error(`libsecret save failed: ${err.message}`);
+    }
+}
+async function linuxLoad() {
+    try {
+        const { stdout } = await execWithTimeout('secret-tool', [
+            'lookup',
+            'service', SERVICE_NAME,
+            'account', ACCOUNT_NAME,
+        ]);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function linuxClear() {
+    try {
+        await execWithTimeout('secret-tool', [
+            'clear',
+            'service', SERVICE_NAME,
+            'account', ACCOUNT_NAME,
+        ]);
+    }
+    catch {
+        // Already cleared
+    }
+}
+// ─── Windows DPAPI ──────────────────────────────────────────────────
+const WIN_CREDENTIAL_DIR = path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), SERVICE_NAME);
+const WIN_CREDENTIAL_FILE = path.join(WIN_CREDENTIAL_DIR, 'credentials.enc');
+async function windowsSave(json) {
+    try {
+        fs.mkdirSync(WIN_CREDENTIAL_DIR, { recursive: true });
+        // Use PowerShell with DPAPI to encrypt. The output is a Base64 string.
+        const psScript = `
+      Add-Type -AssemblyName System.Security
+      $bytes = [System.Text.Encoding]::UTF8.GetBytes('${json.replace(/'/g, "''")}')
+      $encrypted = [System.Security.Cryptography.ProtectedData]::Protect($bytes, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)
+      [Convert]::ToBase64String($encrypted)
+    `;
+        const { stdout } = await execWithTimeout('powershell', ['-NoProfile', '-NonInteractive', '-Command', psScript], 5000);
+        fs.writeFileSync(WIN_CREDENTIAL_FILE, stdout.trim(), 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Windows DPAPI save failed: ${err.message}`);
+    }
+}
+async function windowsLoad() {
+    try {
+        if (!fs.existsSync(WIN_CREDENTIAL_FILE))
+            return null;
+        const encrypted = fs.readFileSync(WIN_CREDENTIAL_FILE, 'utf-8').trim();
+        const psScript = `
+      Add-Type -AssemblyName System.Security
+      $encrypted = [Convert]::FromBase64String('${encrypted}')
+      $bytes = [System.Security.Cryptography.ProtectedData]::Unprotect($encrypted, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)
+      [System.Text.Encoding]::UTF8.GetString($bytes)
+    `;
+        const { stdout } = await execWithTimeout('powershell', ['-NoProfile', '-NonInteractive', '-Command', psScript], 5000);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function windowsClear() {
+    try {
+        if (fs.existsSync(WIN_CREDENTIAL_FILE)) {
+            fs.unlinkSync(WIN_CREDENTIAL_FILE);
+        }
+    }
+    catch {
+        // Ignore
+    }
+}
+// ─── AES-256-GCM Encrypted File Fallback ────────────────────────────
+//
+// Security model note: The encrypted file fallback is intentionally weaker
+// than OS-native keychain storage. The AES key is derived from machine
+// identifiers (hostname + username) which are not secret. An attacker with
+// filesystem access to both the salt file and encrypted file, plus knowledge
+// of the derivation scheme, could reconstruct the key. This is by design —
+// the fallback targets environments (Docker, CI, headless servers) where OS
+// keychains are unavailable. It prevents casual exposure (e.g., `cat` the
+// file, dotfile backups) but is not equivalent to hardware-backed storage.
+// For maximum security, use a desktop environment where OS keychain is available.
+/**
+ * Derives a 256-bit AES key from machine-specific identifiers.
+ * The salt is generated once and persisted to prevent key drift.
+ */
+function deriveEncryptionKey() {
+    let salt;
+    if (fs.existsSync(SALT_FILE)) {
+        salt = Buffer.from(fs.readFileSync(SALT_FILE, 'utf-8'), 'hex');
+    }
+    else {
+        salt = crypto.randomBytes(32);
+        fs.writeFileSync(SALT_FILE, salt.toString('hex'), 'utf-8');
+        setFilePermissions(SALT_FILE);
+    }
+    // Combine machine-specific identifiers for key derivation material
+    let username = 'unknown';
+    try {
+        username = os.userInfo().username;
+    }
+    catch {
+        // os.userInfo() can throw in some minimal Docker containers (ENOENT on /etc/passwd)
+    }
+    const machineId = `${os.hostname()}:${username}:${SERVICE_NAME}`;
+    return crypto.pbkdf2Sync(machineId, salt, 100_000, 32, 'sha512');
+}
+function encryptAES(plaintext) {
+    const key = deriveEncryptionKey();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag().toString('hex');
+    // Store as iv:authTag:ciphertext
+    return `${iv.toString('hex')}:${authTag}:${encrypted}`;
+}
+function decryptAES(blob) {
+    const parts = blob.split(':');
+    if (parts.length !== 3)
+        throw new Error('Invalid encrypted credential format');
+    const [ivHex, authTagHex, ciphertext] = parts;
+    const key = deriveEncryptionKey();
+    const iv = Buffer.from(ivHex, 'hex');
+    const authTag = Buffer.from(authTagHex, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+async function fileSave(json) {
+    const encrypted = encryptAES(json);
+    fs.writeFileSync(ENCRYPTED_FILE, encrypted, 'utf-8');
+    setFilePermissions(ENCRYPTED_FILE);
+}
+async function fileLoad() {
+    try {
+        if (!fs.existsSync(ENCRYPTED_FILE))
+            return null;
+        const blob = fs.readFileSync(ENCRYPTED_FILE, 'utf-8').trim();
+        return decryptAES(blob);
+    }
+    catch {
+        return null;
+    }
+}
+async function fileClear() {
+    try {
+        if (fs.existsSync(ENCRYPTED_FILE))
+            fs.unlinkSync(ENCRYPTED_FILE);
+        if (fs.existsSync(SALT_FILE))
+            fs.unlinkSync(SALT_FILE);
+    }
+    catch {
+        // Ignore
+    }
+}
+/**
+ * Sets restrictive file permissions (owner read/write only) on Unix systems.
+ */
+function setFilePermissions(filePath) {
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+// ─── Public API ─────────────────────────────────────────────────────
+/**
+ * Persists authentication credentials to the most secure available store.
+ *
+ * Strategy (tried in order):
+ * 1. macOS Keychain (`security` CLI)
+ * 2. Linux libsecret (`secret-tool` CLI)
+ * 3. Windows DPAPI (PowerShell)
+ * 4. AES-256-GCM encrypted file with 0600 permissions
+ */
+export async function saveCredentials(data) {
+    const current = await loadCredentials();
+    const merged = { ...current, ...data };
+    const json = JSON.stringify(merged);
+    const backend = await detectBackend();
+    try {
+        switch (backend) {
+            case 'keychain-macos':
+                await macSave(json);
+                break;
+            case 'libsecret-linux':
+                await linuxSave(json);
+                break;
+            case 'dpapi-windows':
+                await windowsSave(json);
+                break;
+            case 'encrypted-file':
+                await fileSave(json);
+                break;
+        }
+    }
+    catch (err) {
+        debugLog(`Primary credential save failed (${backend}): ${err.message}. Falling back to encrypted file.`);
+        // If the OS-native backend fails, fall back to encrypted file
+        if (backend !== 'encrypted-file') {
+            await fileSave(json);
+        }
+        else {
+            throw err;
+        }
+    }
+}
+/**
+ * Loads authentication credentials from the secure store.
+ * Returns an empty object if no credentials are found.
+ *
+ * On first run after upgrade, silently migrates any legacy plaintext
+ * `~/.minovative-mind-cli.json` into the secure store and deletes the old file.
+ */
+export async function loadCredentials() {
+    const backend = await detectBackend();
+    let json = null;
+    try {
+        switch (backend) {
+            case 'keychain-macos':
+                json = await macLoad();
+                break;
+            case 'libsecret-linux':
+                json = await linuxLoad();
+                break;
+            case 'dpapi-windows':
+                json = await windowsLoad();
+                break;
+            case 'encrypted-file':
+                json = await fileLoad();
+                break;
+        }
+    }
+    catch (err) {
+        debugLog(`Primary credential load failed (${backend}): ${err.message}`);
+    }
+    // If the primary backend yielded nothing or threw an error, check the fallback file.
+    // This handles the case where saveCredentials timed out on the keychain and wrote
+    // to the fallback file instead.
+    if (!json && backend !== 'encrypted-file') {
+        try {
+            json = await fileLoad();
+        }
+        catch (err) {
+            debugLog(`Fallback credential load failed: ${err.message}`);
+        }
+    }
+    if (json) {
+        try {
+            return JSON.parse(json);
+        }
+        catch {
+            debugLog('Failed to parse stored credentials — returning empty');
+            return {};
+        }
+    }
+    // No credentials found in secure store — check for legacy plaintext file to migrate
+    const migrated = await migrateLegacyCredentials();
+    if (migrated)
+        return migrated;
+    return {};
+}
+/**
+ * Removes all stored credentials from the secure store.
+ * Also cleans up any legacy plaintext file if it still exists.
+ */
+export async function clearCredentials() {
+    const backend = await detectBackend();
+    try {
+        switch (backend) {
+            case 'keychain-macos':
+                await macClear();
+                break;
+            case 'libsecret-linux':
+                await linuxClear();
+                break;
+            case 'dpapi-windows':
+                await windowsClear();
+                break;
+            case 'encrypted-file':
+                await fileClear();
+                break;
+        }
+    }
+    catch (err) {
+        debugLog(`Credential clear failed (${backend}): ${err.message}`);
+    }
+    // Always attempt to clear the fallback file, as a previous saveCredentials
+    // might have timed out on the OS keychain and written to the fallback instead.
+    if (backend !== 'encrypted-file') {
+        await fileClear();
+    }
+    // Always clean up legacy file on logout
+    removeLegacyFile();
+}
+// ─── Migration ──────────────────────────────────────────────────────
+/**
+ * Silently migrates credentials from the legacy plaintext
+ * `~/.minovative-mind-cli.json` file into the secure store.
+ * Deletes the plaintext file after successful migration.
+ */
+async function migrateLegacyCredentials() {
+    try {
+        if (!fs.existsSync(LEGACY_CONFIG_FILE))
+            return null;
+        const raw = fs.readFileSync(LEGACY_CONFIG_FILE, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!data.idToken && !data.refreshToken)
+            return null;
+        // Save to the new secure store
+        const json = JSON.stringify(data);
+        const backend = await detectBackend();
+        try {
+            switch (backend) {
+                case 'keychain-macos':
+                    await macSave(json);
+                    break;
+                case 'libsecret-linux':
+                    await linuxSave(json);
+                    break;
+                case 'dpapi-windows':
+                    await windowsSave(json);
+                    break;
+                case 'encrypted-file':
+                    await fileSave(json);
+                    break;
+            }
+        }
+        catch (err) {
+            debugLog(`Primary credential save failed during migration (${backend}): ${err.message}. Falling back to encrypted file.`);
+            if (backend !== 'encrypted-file') {
+                await fileSave(json);
+            }
+            else {
+                throw err;
+            }
+        }
+        // Remove the legacy plaintext file
+        removeLegacyFile();
+        debugLog('Successfully migrated legacy plaintext credentials to secure storage');
+        return data;
+    }
+    catch (err) {
+        debugLog(`Legacy credential migration failed: ${err.message}`);
+        return null;
+    }
+}
+function removeLegacyFile() {
+    try {
+        if (fs.existsSync(LEGACY_CONFIG_FILE)) {
+            fs.unlinkSync(LEGACY_CONFIG_FILE);
+        }
+    }
+    catch {
+        // Best effort
+    }
+}

package/dist/utils/projectStorage.js

@@ -60,6 +60,76 @@ export function ensureIgnored(workspaceRoot) {
             }
         }
     }
+    ensureMinovativeMindIgnore(workspaceRoot);
+}
+/**
+ * Creates a default .minovativemindignore file if it doesn't exist, pre-populated with
+ * sensible defaults for files that the AI should ignore but Git might track.
+ */
+function ensureMinovativeMindIgnore(workspaceRoot) {
+    const filePath = path.join(workspaceRoot, '.minovativemindignore');
+    if (!fs.existsSync(filePath)) {
+        const template = `# Minovative Mind CLI Ignore File
+    
+# This file works exactly like .gitignore, but applies ONLY to the Minovative Mind CLI AI agent.
+
+# Use it to block the CLI AI agent from reading large/redundant files or any files/folders that you would like the AI agent not to read but still want tracked by Git.
+
+# Lockfiles (Huge token wasters, AI should read package.json instead)
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+poetry.lock
+Cargo.lock
+
+# Massive Data Dumps
+*.sql
+*.sqlite
+*.dump
+*.csv
+
+# Built/Minified Assets
+*.min.js
+*.bundle.js
+*.map
+
+# Media / Binary
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.mp4
+*.mp3
+*.wav
+*.ico
+*.svg
+*.pdf
+
+# Archives
+*.zip
+*.tar
+*.tar.gz
+*.rar
+*.7z
+
+# Compiled Binaries
+*.exe
+*.dll
+*.so
+*.dylib
+*.class
+*.pyc
+
+# Logs
+*.log
+`;
+        try {
+            fs.writeFileSync(filePath, template, 'utf-8');
+        }
+        catch (e) {
+            // ignore
+        }
+    }
 }
 /**
  * Reads a JSON file from the project's .minovativemind directory.