filemayor 2.1.0 → 4.0.5

package/core/intent-interpreter.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR v3.0 — INTENT INTERPRETER
+ * AI Logic Layer: Bridges fuzzy human language and atomic execution.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { getLicenseInfo } = require('./license');
+
+const GEMINI_MODEL = 'gemini-2.0-flash';
+const GEMINI_ENDPOINT = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent`;
+const PROXY_URL = process.env.FM_AI_PROXY_URL || 'https://filemayor.com/api/ai/plan';
+
+// Stable device ID based on hostname + username (no PII sent to server)
+function getDeviceId() {
+    const raw = `${os.hostname()}-${os.userInfo().username}`;
+    return crypto.createHash('sha256').update(raw).digest('hex').slice(0, 32);
+}
+
+function getSystemPrompt() {
+    return `You are FileMayor's AI planning engine. Given a description of a messy folder and a user's intent, output a structured JSON plan.
+
+Respond ONLY with valid JSON in this exact format:
+{
+  "summary": "one sentence describing what the plan does",
+  "operations": [
+    { "action": "move", "from": "relative/path/file.ext", "to": "Category/file.ext" },
+    { "action": "rename", "from": "old_name.ext", "to": "new_name.ext" },
+    { "action": "delete", "path": "junk_file.tmp" }
+  ],
+  "warnings": ["optional list of things user should review"]
+}`;
+}
+
+async function callAi(prompt, context) {
+    const provider = process.env.FM_AI_PROVIDER || 'proxy';
+    const apiKey = process.env.FM_AI_API_KEY || process.env.GEMINI_API_KEY || '';
+
+    if (provider === 'gemini' && apiKey) {
+        return callGeminiDirect(prompt, context, apiKey);
+    }
+    if (provider === 'openai' && apiKey) {
+        return callOpenAI(prompt, context, apiKey);
+    }
+    if (provider === 'anthropic' && apiKey) {
+        return callAnthropic(prompt, context, apiKey);
+    }
+    if (provider === 'ollama') {
+        return callOllama(prompt, context);
+    }
+    // Default: use the FileMayor proxy
+    return callProxy(prompt, context);
+}
+
+async function callProxy(prompt, context) {
+    const licenseInfo = getLicenseInfo();
+    const token = licenseInfo?.key || getDeviceId();
+
+    const res = await fetch(PROXY_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            prompt,
+            context,
+            deviceId: getDeviceId(),
+        }),
+    });
+
+    if (res.status === 429) {
+        const body = await res.json();
+        throw new Error(body.error || 'Monthly AI limit reached. Upgrade to Pro for unlimited access.');
+    }
+
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error || `AI service error (${res.status})`);
+    }
+
+    const body = await res.json();
+    if (body.error && !body.plan) throw new Error(body.error);
+    return body.plan;
+}
+
+async function callGeminiDirect(prompt, context, apiKey) {
+    const systemPrompt = getSystemPrompt();
+
+    const body = {
+        contents: [{
+            parts: [{
+                text: `${systemPrompt}\n\nUser request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}`
+            }]
+        }],
+        generationConfig: {
+            temperature: 0.1,
+            topP: 0.95,
+            maxOutputTokens: 2048,
+            responseMimeType: 'application/json',
+        },
+    };
+
+    const url = `${GEMINI_ENDPOINT}?key=${apiKey}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Gemini API Error: ${response.status} - ${err}`);
+    }
+
+    const data = await response.json();
+    const rawText = data?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error('No JSON found in AI response');
+    return JSON.parse(jsonMatch[0]);
+}
+
+async function callOpenAI(prompt, context, apiKey) {
+    const systemPrompt = getSystemPrompt();
+    const res = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({
+            model: 'gpt-4o',
+            response_format: { type: 'json_object' },
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: `User request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}` }
+            ]
+        })
+    });
+    if (!res.ok) throw new Error(`OpenAI error: ${res.status}`);
+    const data = await res.json();
+    return JSON.parse(data.choices[0].message.content);
+}
+
+async function callAnthropic(prompt, context, apiKey) {
+    const systemPrompt = getSystemPrompt();
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({
+            model: 'claude-3-5-haiku-20241022',
+            max_tokens: 1024,
+            system: systemPrompt,
+            messages: [{ role: 'user', content: `User request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}` }]
+        })
+    });
+    if (!res.ok) throw new Error(`Anthropic error: ${res.status}`);
+    const data = await res.json();
+    const text = data.content[0].text;
+    return JSON.parse(text.replace(/```json\n?|\n?```/g, '').trim());
+}
+
+async function callOllama(prompt, context) {
+    const model = process.env.FM_OLLAMA_MODEL || 'llama3';
+    const baseUrl = process.env.FM_OLLAMA_BASE_URL || 'http://localhost:11434';
+    const systemPrompt = getSystemPrompt();
+    const res = await fetch(`${baseUrl}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            prompt: `${systemPrompt}\n\nUser request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}`,
+            stream: false,
+            format: 'json'
+        })
+    });
+    if (!res.ok) throw new Error(`Ollama error: ${res.status}`);
+    const data = await res.json();
+    return JSON.parse(data.response);
+}
+
+class IntentInterpreter {
+    constructor(apiKey) {
+        this.apiKey = apiKey || process.env.GEMINI_API_KEY;
+        // No warning needed — proxy works without a key
+    }
+
+    /**
+     * Interpret a user prompt against clustered telemetry
+     * @param {string} userPrompt
+     * @param {Object} clusters - From MetadataSentry
+     * @param {Object} context
+     * @returns {Promise<Object>} The Curative Plan
+     */
+    async interpret(userPrompt, clusters, context = {}) {
+        const telemetry = this._summarizeFiles(clusters);
+        const promptWithTelemetry = `USER INTENT: "${userPrompt}"\n\nFILES:\n${JSON.stringify(telemetry, null, 2)}`;
+
+        const proxyContext = {
+            ...context,
+            fileCount: Object.values(clusters).reduce((sum, cat) => sum + (cat.count || 0), 0),
+            categories: Object.keys(clusters),
+            topFiles: Object.values(clusters).flatMap(cat => (cat.samples || []).slice(0, 3).map(s => s.name)),
+        };
+
+        // If apiKey was explicitly passed (non-env), inject it temporarily for the direct path
+        const prevKey = process.env.GEMINI_API_KEY;
+        const prevAiKey = process.env.FM_AI_API_KEY;
+        if (this.apiKey && this.apiKey !== prevKey) {
+            process.env.FM_AI_API_KEY = this.apiKey;
+        }
+
+        let curativePlan;
+        try {
+            curativePlan = await callAi(promptWithTelemetry, proxyContext);
+        } finally {
+            // Restore original env key if we temporarily set one
+            if (this.apiKey && this.apiKey !== prevKey) {
+                if (prevAiKey === undefined) {
+                    delete process.env.FM_AI_API_KEY;
+                } else {
+                    process.env.FM_AI_API_KEY = prevAiKey;
+                }
+            }
+        }
+
+        // If the proxy returned a raw plan object rather than a full curative plan shape,
+        // wrap it so downstream code always sees { narrative, plan, confidence }
+        if (curativePlan && !curativePlan.plan && !curativePlan.narrative) {
+            curativePlan = { narrative: '', plan: curativePlan, confidence: 80 };
+        }
+
+        // [Production Grade] Confidence Gating
+        if (curativePlan.confidence < 60) {
+            curativePlan.status = 'low_confidence';
+            curativePlan.message = 'I am not entirely sure about this request. Could you clarify your intent?';
+        }
+
+        // [Production Grade] Plan Validation
+        curativePlan.plan = this._validatePlan(curativePlan.plan);
+
+        return curativePlan;
+    }
+
+    /**
+     * Summarize clustered file list for AI ingestion
+     */
+    _summarizeFiles(clusters) {
+        const summary = {};
+
+        for (const cat in clusters) {
+            summary[cat] = {
+                count: clusters[cat].count,
+                samples: clusters[cat].samples.map(s => ({
+                    name: s.name,
+                    path: s.path,
+                    ancestry: s.ancestry,
+                    bundleId: s.bundleId
+                }))
+            };
+        }
+
+        return summary;
+    }
+
+    /**
+     * Validate plan entries from AI response
+     * Filters out any entries missing required fields
+     */
+    _validatePlan(plan) {
+        if (!Array.isArray(plan)) return [];
+        return plan.filter(entry => {
+            if (!entry || typeof entry !== 'object') return false;
+            if (!entry.source || typeof entry.source !== 'string') return false;
+            if (!entry.destination || typeof entry.destination !== 'string') return false;
+            if (!entry.reason) entry.reason = 'AI suggested move';
+            return true;
+        });
+    }
+
+    _parseResponse(rawText) {
+        try {
+            const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) throw new Error('No JSON found in AI response');
+            return JSON.parse(jsonMatch[0]);
+        } catch (err) {
+            console.error('[FAIL] Failed to parse AI response:', rawText);
+            throw new Error(`AI Parsing Error: ${err.message}`);
+        }
+    }
+}
+
+module.exports = IntentInterpreter;

package/core/jailer.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — THE JAILER (IMMUTABLE SECURITY LAYER)
+ * 
+ * This is the final firewall between FileMayor's AI "intuition" and
+ * the actual operating system. Even if Gemini suggests moving files
+ * into System32, this module kills the operation cold.
+ * 
+ * CRITICAL: This file must NEVER be modified by AI assistants.
+ * It is the immutable source of truth for filesystem safety.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// ─── Forbidden Zones (OS-Agnostic) ───────────────────────────────
+const FORBIDDEN_ZONES = [
+    // Windows
+    'C:\\Windows', 'C:\\Program Files', 'C:\\Program Files (x86)',
+    'C:\\ProgramData', 'C:\\Users\\Public', 'C:\\Users\\Default',
+    // Linux / macOS
+    '/etc', '/usr', '/bin', '/sbin', '/var', '/root',
+    '/boot', '/dev', '/proc', '/sys', '/run',
+    // macOS specific
+    '/System', '/Library', '/private'
+].map(p => path.resolve(p).toLowerCase());
+
+/**
+ * THE JAILER: Final security check for ALL FileMayor operations.
+ * Use this before ANY fs.rename, fs.unlink, or fs.copy operation.
+ */
+class FileMayorJailer {
+    /**
+     * @param {string} rootDirectory - The user's working directory (the "jail")
+     */
+    constructor(rootDirectory = process.cwd()) {
+        // Resolve the root to its absolute, REAL path (no symlinks)
+        try {
+            this.safeRoot = fs.realpathSync(path.resolve(rootDirectory)).toLowerCase();
+        } catch {
+            this.safeRoot = path.resolve(rootDirectory).toLowerCase();
+        }
+    }
+
+    /**
+     * Validate that a target path is safe for FileMayor to operate on.
+     * Resolves symlinks to their TRUE destination before checking.
+     * 
+     * @param {string} targetPath - The path to validate
+     * @returns {{ safe: boolean, realPath: string, error?: string }}
+     */
+    validate(targetPath) {
+        try {
+            if (!targetPath || typeof targetPath !== 'string') {
+                return { safe: false, realPath: '', error: 'Empty or invalid path' };
+            }
+
+            // Reject null bytes (classic injection vector)
+            if (targetPath.includes('\0')) {
+                return { safe: false, realPath: '', error: 'Null byte injection detected' };
+            }
+
+            const absoluteTarget = path.resolve(targetPath);
+
+            // [ANTI-SYMLINK] Resolve the REAL path (follows symlinks to true source)
+            // This defeats CVE-2025-55130 style symlink race conditions
+            let realTarget;
+            try {
+                realTarget = fs.existsSync(absoluteTarget)
+                    ? fs.realpathSync(absoluteTarget)
+                    : absoluteTarget;
+            } catch {
+                realTarget = absoluteTarget;
+            }
+
+            const normalizedTarget = realTarget.toLowerCase();
+
+            // [JAIL CHECK] Is the target inside our allowed project folder?
+            if (!normalizedTarget.startsWith(this.safeRoot + path.sep) &&
+                normalizedTarget !== this.safeRoot) {
+                return {
+                    safe: false,
+                    realPath: realTarget,
+                    error: `JAIL BREACH: "${realTarget}" is outside the safe root "${this.safeRoot}"`
+                };
+            }
+
+            // [SYSTEM CHECK] Is the target a protected OS zone?
+            for (const zone of FORBIDDEN_ZONES) {
+                if (normalizedTarget.startsWith(zone + path.sep) || normalizedTarget === zone) {
+                    return {
+                        safe: false,
+                        realPath: realTarget,
+                        error: `SYSTEM PROTECTION: "${realTarget}" is within forbidden zone "${zone}"`
+                    };
+                }
+            }
+
+            // [EXTENSION CHECK] Reject system-critical file types
+            const ext = path.extname(realTarget).toLowerCase();
+            const dangerousExts = new Set(['.sys', '.drv', '.dll', '.so', '.dylib', '.kext', '.plist', '.reg']);
+            if (dangerousExts.has(ext)) {
+                return {
+                    safe: false,
+                    realPath: realTarget,
+                    error: `DANGEROUS FILE: "${ext}" files are system-critical and cannot be moved`
+                };
+            }
+
+            return { safe: true, realPath: realTarget };
+
+        } catch (err) {
+            return { safe: false, realPath: '', error: `Jailer error: ${err.message}` };
+        }
+    }
+
+    /**
+     * Validate a move operation (both source AND destination must be safe)
+     * @param {string} source - Source file path
+     * @param {string} destination - Destination file path
+     * @returns {{ safe: boolean, error?: string }}
+     */
+    validateMove(source, destination) {
+        const srcCheck = this.validate(source);
+        if (!srcCheck.safe) return { safe: false, error: `Source: ${srcCheck.error}` };
+
+        const dstCheck = this.validate(destination);
+        if (!dstCheck.safe) return { safe: false, error: `Destination: ${dstCheck.error}` };
+
+        return { safe: true };
+    }
+}
+
+// ─── Root/Sudo Kill-Switch ────────────────────────────────────────
+// If running as root on Unix, exit immediately. FileMayor should
+// NEVER have elevated privileges to limit blast radius.
+function enforceUserSpace() {
+    if (typeof process.getuid === 'function' && process.getuid() === 0) {
+        console.error('❌ FILEMAYOR SECURITY ERROR: Running as root/sudo is strictly forbidden.');
+        console.error('   FileMayor is designed to run in User Space only.');
+        process.exit(1);
+    }
+}
+
+module.exports = { FileMayorJailer, enforceUserSpace, FORBIDDEN_ZONES };