unix-disk-mcp 0.1.0

package/dist/commands/setup.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import * as readline from "readline";
+import { getConfigPath, getConfigDir } from "../config/index.js";
+const DEFAULT_PROTECTED_PATHS = [
+    "/System",
+    "/Library",
+    "~/.ssh",
+    "~/.gnupg",
+];
+const MCP_CONFIGS = {
+    vscode: {
+        name: "VS Code",
+        path: process.platform === 'darwin'
+            ? join(homedir(), "Library", "Application Support", "Code", "User", "mcp.json")
+            : join(homedir(), ".config", "Code", "User", "mcp.json"),
+    },
+    claude: {
+        name: "Claude Desktop",
+        path: process.platform === 'darwin'
+            ? join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")
+            : join(homedir(), ".config", "Claude", "claude_desktop_config.json"),
+    },
+};
+/**
+ * Create readline interface for user input
+ */
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+/**
+ * Ask a question and return the answer
+ */
+function ask(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Print welcome banner
+ */
+function printBanner() {
+    console.log("╔════════════════════════════════════════════════════════════════╗");
+    console.log("║           Unix Disk MCP - Setup Wizard                        ║");
+    console.log("╚════════════════════════════════════════════════════════════════╝\n");
+}
+/**
+ * Configure protected paths
+ */
+async function configureProtectedPaths(rl) {
+    console.log("\n📁 Protected Paths Configuration\n");
+    console.log("Protected paths cannot be deleted by AI. These are recursive (includes subdirectories).\n");
+    console.log("Default protected paths:");
+    DEFAULT_PROTECTED_PATHS.forEach((path, i) => {
+        console.log(`  ${i + 1}. ${path}`);
+    });
+    const answer = await ask(rl, "\nUse default protected paths? [Y/n]: ");
+    if (answer.toLowerCase() === "n") {
+        console.log("\nEnter protected paths (one per line, empty line to finish):");
+        const paths = [];
+        while (true) {
+            const path = await ask(rl, "Path: ");
+            if (!path.trim())
+                break;
+            paths.push(path.trim());
+        }
+        return paths.length > 0 ? paths : DEFAULT_PROTECTED_PATHS;
+    }
+    return DEFAULT_PROTECTED_PATHS;
+}
+/**
+ * Select MCP client to configure
+ */
+async function selectMCPClient(rl) {
+    console.log("\n🔧 MCP Client Configuration\n");
+    console.log("Which MCP client would you like to configure?\n");
+    console.log("  1. VS Code (Roo Cline)");
+    console.log("  2. Claude Desktop");
+    console.log("  3. Both");
+    console.log("  4. None (manual configuration)\n");
+    const answer = await ask(rl, "Select [1-4]: ");
+    switch (answer.trim()) {
+        case "1":
+            return "vscode";
+        case "2":
+            return "claude";
+        case "3":
+            return "both";
+        case "4":
+        default:
+            return "none";
+    }
+}
+/**
+ * Update MCP client config
+ */
+function updateMCPConfig(client, configPath) {
+    const config = MCP_CONFIGS[client];
+    if (!existsSync(config.path)) {
+        console.log(`❌ ${config.name} config not found at: ${config.path}`);
+        return false;
+    }
+    try {
+        const raw = readFileSync(config.path, "utf-8");
+        const data = JSON.parse(raw);
+        if (client === "vscode") {
+            // VS Code MCP config format
+            if (!data.servers) {
+                data.servers = {};
+            }
+            data.servers["unix-disk-mcp"] = {
+                type: "stdio",
+                command: "unix-disk-mcp",
+            };
+        }
+        else {
+            // Claude Desktop config format
+            if (!data.mcpServers) {
+                data.mcpServers = {};
+            }
+            data.mcpServers["unix-disk-mcp"] = {
+                command: "unix-disk-mcp",
+                args: [],
+            };
+        }
+        writeFileSync(config.path, JSON.stringify(data, null, 2));
+        console.log(`✅ Updated ${config.name} config`);
+        return true;
+    }
+    catch (error) {
+        console.log(`❌ Failed to update ${config.name} config: ${error.message}`);
+        return false;
+    }
+}
+/**
+ * Save configuration
+ */
+function saveConfig(config) {
+    const configPath = getConfigPath();
+    const configDir = getConfigDir();
+    // Ensure config directory exists
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`\n✅ Configuration saved to: ${configPath}`);
+}
+/**
+ * Print manual configuration instructions
+ */
+function printManualInstructions() {
+    console.log("\n╔════════════════════════════════════════════════════════════════╗");
+    console.log("║                Manual Configuration                            ║");
+    console.log("╚════════════════════════════════════════════════════════════════╝\n");
+    console.log("Add this to your MCP client configuration:\n");
+    console.log(JSON.stringify({
+        "unix-disk-mcp": {
+            command: "unix-disk-mcp",
+            args: [],
+        },
+    }, null, 2));
+    console.log("\n\nVS Code (Roo Cline):");
+    console.log(`  ${MCP_CONFIGS.vscode.path}\n`);
+    console.log("Claude Desktop:");
+    console.log(`  ${MCP_CONFIGS.claude.path}\n`);
+}
+/**
+ * Main setup function
+ */
+export async function runSetup() {
+    printBanner();
+    const rl = createInterface();
+    try {
+        // Configure protected paths
+        const protectedPaths = await configureProtectedPaths(rl);
+        // Save config
+        const config = {
+            protected_paths: protectedPaths,
+        };
+        saveConfig(config);
+        // Select and configure MCP client
+        const client = await selectMCPClient(rl);
+        if (client === "none") {
+            printManualInstructions();
+        }
+        else {
+            if (client === "vscode" || client === "both") {
+                updateMCPConfig("vscode", getConfigPath());
+            }
+            if (client === "claude" || client === "both") {
+                updateMCPConfig("claude", getConfigPath());
+            }
+            console.log("\n✅ Setup complete! Restart your MCP client to use the server.\n");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1,11 @@
+export interface Config {
+    protected_paths: string[];
+    ignore_patterns: string[];
+    max_delete_size_gb: number;
+    dry_run: boolean;
+}
+export declare function expandPath(path: string): string;
+export declare function loadConfig(): Config;
+export declare function isProtectedPath(path: string, config: Config): boolean;
+export declare function getConfigPath(): string;
+export declare function getConfigDir(): string;

package/dist/config/index.js

@@ -0,0 +1,59 @@
+import { readFileSync, existsSync, mkdirSync, copyFileSync } from "fs";
+import { homedir } from "os";
+import { resolve, join, dirname } from "path";
+import { fileURLToPath } from "url";
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// XDG Base Directory paths
+const XDG_CONFIG_HOME = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+const CONFIG_DIR = join(XDG_CONFIG_HOME, "unix-disk-mcp");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+// Get the directory where the package is installed (for config.sample.json)
+function getPackageRoot() {
+    // In development: src/config/index.ts -> project root is 2 levels up
+    // In production: dist/config/index.js -> project root is 2 levels up
+    return resolve(__dirname, "../..");
+}
+const SAMPLE_CONFIG_PATH = join(getPackageRoot(), "config.sample.json");
+export function expandPath(path) {
+    if (path.startsWith("~")) {
+        return path.replace("~", homedir());
+    }
+    return path;
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    if (!existsSync(CONFIG_PATH)) {
+        // Copy sample config on first run
+        if (existsSync(SAMPLE_CONFIG_PATH)) {
+            copyFileSync(SAMPLE_CONFIG_PATH, CONFIG_PATH);
+            console.error(`Created config file: ${CONFIG_PATH}`);
+            console.error(`Please review and adjust settings, especially protected_paths.`);
+        }
+        else {
+            console.error(`Config file not found: ${CONFIG_PATH}`);
+            console.error(`Sample config not found: ${SAMPLE_CONFIG_PATH}`);
+            console.error(`Please create a config file manually or run: unix-disk-mcp setup`);
+            process.exit(1);
+        }
+    }
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(raw);
+    // Expand ~ in paths
+    config.protected_paths = config.protected_paths.map(expandPath);
+    return config;
+}
+export function isProtectedPath(path, config) {
+    const normalizedPath = expandPath(path);
+    return config.protected_paths.some((protected_path) => normalizedPath === protected_path ||
+        normalizedPath.startsWith(protected_path + "/"));
+}
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export function getConfigDir() {
+    return CONFIG_DIR;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,13 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config/index.js";
+import { createServer } from "./server.js";
+async function main() {
+    const config = loadConfig();
+    const server = createServer(config);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Config } from "./config/index.js";
+export declare function createServer(config: Config): McpServer;

package/dist/server.js

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerExplorationTools } from "./tools/exploration.js";
+import { registerDiscoveryTools } from "./tools/discovery.js";
+import { registerStagingTools } from "./tools/staging.js";
+export function createServer(config) {
+    const server = new McpServer({
+        name: "unix-disk-mcp",
+        version: "0.1.0",
+    });
+    // Register all tools
+    registerExplorationTools(server, config);
+    registerDiscoveryTools(server, config);
+    registerStagingTools(server, config);
+    return server;
+}

package/dist/tools/discovery.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Config } from "../config/index.js";
+export declare function registerDiscoveryTools(server: McpServer, config: Config): void;

package/dist/tools/discovery.js

@@ -0,0 +1,267 @@
+import { z } from "zod";
+import { execSync } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+export function registerDiscoveryTools(server, config) {
+    // list_applications
+    server.tool("list_applications", "List installed applications with size and last opened date", {}, async () => {
+        try {
+            if (process.platform !== 'darwin') {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "list_applications is only supported on macOS",
+                                code: "PLATFORM_NOT_SUPPORTED",
+                                note: "Linux application discovery not yet implemented. Use find_large_items on /usr/share/applications or ~/.local/share/applications",
+                            }),
+                        },
+                    ],
+                };
+            }
+            // macOS: Use Spotlight
+            const appDirs = ["/Applications", join(process.env.HOME || "", "Applications")];
+            const apps = [];
+            for (const dir of appDirs) {
+                if (!existsSync(dir))
+                    continue;
+                const entries = readdirSync(dir).filter((name) => name.endsWith(".app"));
+                for (const name of entries) {
+                    const appPath = join(dir, name);
+                    try {
+                        // Get size using du
+                        const duOutput = execSync(`du -sk "${appPath}" 2>/dev/null`, {
+                            encoding: "utf-8",
+                        });
+                        const size = parseInt(duOutput.split("\t")[0]) * 1024;
+                        // Get last opened using mdls (Spotlight metadata)
+                        let lastOpened = null;
+                        try {
+                            const mdlsOutput = execSync(`mdls -name kMDItemLastUsedDate -raw "${appPath}" 2>/dev/null`, { encoding: "utf-8" });
+                            if (mdlsOutput && !mdlsOutput.includes("null")) {
+                                lastOpened = new Date(mdlsOutput.trim()).toISOString();
+                            }
+                        }
+                        catch {
+                            // Spotlight metadata not available
+                        }
+                        apps.push({
+                            name: name.replace(".app", ""),
+                            path: appPath,
+                            size,
+                            last_opened: lastOpened,
+                        });
+                    }
+                    catch {
+                        apps.push({
+                            name: name.replace(".app", ""),
+                            path: appPath,
+                            size: null,
+                            last_opened: null,
+                        });
+                    }
+                }
+            }
+            // Sort by size descending
+            apps.sort((a, b) => (b.size || 0) - (a.size || 0));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, data: apps }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : "Unknown error",
+                            code: "LIST_APPLICATIONS_FAILED",
+                        }),
+                    },
+                ],
+            };
+        }
+    });
+    // list_homebrew
+    server.tool("list_homebrew", "List Homebrew packages (formulas and casks)", {
+        include_casks: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Include casks in the list"),
+    }, async ({ include_casks }) => {
+        try {
+            // Check if Homebrew is installed
+            try {
+                execSync("which brew", { encoding: "utf-8" });
+            }
+            catch {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Homebrew is not installed",
+                                code: "HOMEBREW_NOT_FOUND",
+                            }),
+                        },
+                    ],
+                };
+            }
+            const packages = [];
+            // Get formulas
+            const formulaOutput = execSync("brew list --formula --versions 2>/dev/null", {
+                encoding: "utf-8",
+            });
+            for (const line of formulaOutput.trim().split("\n")) {
+                if (!line)
+                    continue;
+                const parts = line.split(" ");
+                packages.push({
+                    name: parts[0],
+                    type: "formula",
+                    version: parts.slice(1).join(" "),
+                });
+            }
+            // Get casks
+            if (include_casks) {
+                try {
+                    const caskOutput = execSync("brew list --cask --versions 2>/dev/null", {
+                        encoding: "utf-8",
+                    });
+                    for (const line of caskOutput.trim().split("\n")) {
+                        if (!line)
+                            continue;
+                        const parts = line.split(" ");
+                        packages.push({
+                            name: parts[0],
+                            type: "cask",
+                            version: parts.slice(1).join(" "),
+                        });
+                    }
+                }
+                catch {
+                    // No casks installed
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, data: packages }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : "Unknown error",
+                            code: "LIST_HOMEBREW_FAILED",
+                        }),
+                    },
+                ],
+            };
+        }
+    });
+    // list_docker
+    server.tool("list_docker", "List Docker images, containers, and volumes", {
+        resource_type: z
+            .enum(["images", "containers", "volumes", "all"])
+            .optional()
+            .default("all")
+            .describe("Type of Docker resources to list"),
+    }, async ({ resource_type }) => {
+        try {
+            // Check if Docker is available
+            try {
+                execSync("docker info 2>/dev/null", { encoding: "utf-8" });
+            }
+            catch {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Docker is not running or not installed",
+                                code: "DOCKER_NOT_AVAILABLE",
+                            }),
+                        },
+                    ],
+                };
+            }
+            const result = {};
+            if (resource_type === "all" || resource_type === "images") {
+                const output = execSync('docker images --format "{{.ID}}|{{.Repository}}|{{.Tag}}|{{.Size}}|{{.CreatedAt}}"', { encoding: "utf-8" });
+                result.images = output
+                    .trim()
+                    .split("\n")
+                    .filter((line) => line)
+                    .map((line) => {
+                    const [id, repository, tag, size, created] = line.split("|");
+                    return { id, repository, tag, size, created };
+                });
+            }
+            if (resource_type === "all" || resource_type === "containers") {
+                const output = execSync('docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.Size}}"', { encoding: "utf-8" });
+                result.containers = output
+                    .trim()
+                    .split("\n")
+                    .filter((line) => line)
+                    .map((line) => {
+                    const [id, name, image, status, size] = line.split("|");
+                    return { id, name, image, status, size };
+                });
+            }
+            if (resource_type === "all" || resource_type === "volumes") {
+                const output = execSync('docker volume ls --format "{{.Name}}|{{.Driver}}"', {
+                    encoding: "utf-8",
+                });
+                result.volumes = output
+                    .trim()
+                    .split("\n")
+                    .filter((line) => line)
+                    .map((line) => {
+                    const [name, driver] = line.split("|");
+                    return { name, driver, size: null }; // Volume size requires inspection
+                });
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, data: result }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : "Unknown error",
+                            code: "LIST_DOCKER_FAILED",
+                        }),
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/exploration.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Config } from "../config/index.js";
+export declare function registerExplorationTools(server: McpServer, config: Config): void;