macha-ai 0.1.0 → 0.1.1

package/dist/ai/tools.js

@@ -147,20 +147,68 @@ export const TOOL_DEFINITIONS = [
         },
     },
 ];
-function safePath(workingDir, filePath) {
+function safePathLexical(workingDir, filePath) {
     const base = path.resolve(workingDir);
     const resolved = path.resolve(base, filePath);
     const rel = path.relative(base, resolved);
     if (rel.startsWith("..") || path.isAbsolute(rel)) {
-        throw new Error(`Path traversal denied: ${filePath} escapes working directory`);
+        throw new Error(`Path traversal denied: "${filePath}" escapes working directory`);
     }
     return resolved;
 }
+async function safeExistingPath(workingDir, filePath) {
+    const lexical = safePathLexical(workingDir, filePath);
+    const realBase = await fs.realpath(path.resolve(workingDir));
+    let real;
+    try {
+        real = await fs.realpath(lexical);
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === "ENOENT") {
+            throw new Error(`File not found: "${filePath}"`);
+        }
+        throw e;
+    }
+    const rel = path.relative(realBase, real);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`Symlink escape denied: "${filePath}" resolves outside working directory`);
+    }
+    return real;
+}
+async function safeNewPath(workingDir, filePath) {
+    const lexical = safePathLexical(workingDir, filePath);
+    const realBase = await fs.realpath(path.resolve(workingDir));
+    let ancestor = path.dirname(lexical);
+    while (true) {
+        try {
+            const realAncestor = await fs.realpath(ancestor);
+            const rel = path.relative(realBase, realAncestor);
+            if (rel.startsWith("..") || path.isAbsolute(rel)) {
+                throw new Error(`Symlink escape denied: parent of "${filePath}" resolves outside working directory`);
+            }
+            break;
+        }
+        catch (e) {
+            const err = e;
+            if (err.code === "ENOENT") {
+                const parent = path.dirname(ancestor);
+                if (parent === ancestor)
+                    break;
+                ancestor = parent;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return lexical;
+}
 export async function executeTool(name, args, workingDir) {
     try {
         switch (name) {
             case "read_file": {
-                const filePath = safePath(workingDir, args.path);
+                const filePath = await safeExistingPath(workingDir, args.path);
                 const content = await fs.readFile(filePath, "utf-8");
                 const lines = content.split("\n");
                 const preview = lines.length > 500
@@ -170,7 +218,7 @@ export async function executeTool(name, args, workingDir) {
                 return { success: true, output: preview };
             }
             case "write_file": {
-                const filePath = safePath(workingDir, args.path);
+                const filePath = await safeNewPath(workingDir, args.path);
                 await fs.mkdir(path.dirname(filePath), { recursive: true });
                 await fs.writeFile(filePath, args.content, "utf-8");
                 return {
@@ -180,7 +228,7 @@ export async function executeTool(name, args, workingDir) {
             }
             case "list_files": {
                 const dirPath = args.path
-                    ? safePath(workingDir, args.path)
+                    ? await safeExistingPath(workingDir, args.path)
                     : workingDir;
                 const maxDepth = Math.min(args.depth || 2, 5);
                 const patterns = Array.from({ length: maxDepth }, (_, i) => `${"*/".repeat(i + 1)}*`);
@@ -237,7 +285,11 @@ export async function executeTool(name, args, workingDir) {
                 const globPat = args.glob || "**/*";
                 const caseSensitive = args.case_sensitive || false;
                 if (globPat.includes("..")) {
-                    return { success: false, output: "", error: "Glob pattern must not contain '..'" };
+                    return {
+                        success: false,
+                        output: "",
+                        error: "Glob pattern must not contain '..'",
+                    };
                 }
                 const files = await fg(globPat, {
                     cwd: workingDir,
@@ -252,10 +304,16 @@ export async function executeTool(name, args, workingDir) {
                 });
                 const results = [];
                 const regex = new RegExp(query, caseSensitive ? "g" : "gi");
+                const realBase = await fs.realpath(path.resolve(workingDir));
                 for (const file of files.slice(0, 200)) {
                     let resolvedFilePath;
                     try {
-                        resolvedFilePath = safePath(workingDir, file);
+                        const lexical = safePathLexical(workingDir, file);
+                        const real = await fs.realpath(lexical);
+                        const rel = path.relative(realBase, real);
+                        if (rel.startsWith("..") || path.isAbsolute(rel))
+                            continue;
+                        resolvedFilePath = real;
                     }
                     catch {
                         continue;
@@ -287,13 +345,13 @@ export async function executeTool(name, args, workingDir) {
                 };
             }
             case "delete_file": {
-                const filePath = safePath(workingDir, args.path);
+                const filePath = await safeExistingPath(workingDir, args.path);
                 await fs.unlink(filePath);
                 return { success: true, output: `Deleted ${args.path}` };
             }
             case "move_file": {
-                const from = safePath(workingDir, args.from);
-                const to = safePath(workingDir, args.to);
+                const from = await safeExistingPath(workingDir, args.from);
+                const to = await safeNewPath(workingDir, args.to);
                 await fs.mkdir(path.dirname(to), { recursive: true });
                 await fs.rename(from, to);
                 return { success: true, output: `Moved ${args.from} → ${args.to}` };

package/dist/mcp/client.js

@@ -1,4 +1,43 @@
 import { execa } from "execa";
+function writeMessage(state, msg) {
+    const body = JSON.stringify(msg);
+    const header = `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n`;
+    state.process.stdin?.write(header + body);
+}
+function parseFrames(state) {
+    const messages = [];
+    while (true) {
+        const buf = state.buffer;
+        const sep = findCRLFCRLF(buf);
+        if (sep === -1)
+            break;
+        const headerStr = buf.slice(0, sep).toString("utf-8");
+        const contentLengthMatch = headerStr.match(/Content-Length:\s*(\d+)/i);
+        if (!contentLengthMatch) {
+            state.buffer = buf.slice(sep + 4);
+            continue;
+        }
+        const bodyLen = parseInt(contentLengthMatch[1], 10);
+        const bodyStart = sep + 4;
+        const bodyEnd = bodyStart + bodyLen;
+        if (buf.length < bodyEnd)
+            break;
+        messages.push(buf.slice(bodyStart, bodyEnd).toString("utf-8"));
+        state.buffer = buf.slice(bodyEnd);
+    }
+    return messages;
+}
+function findCRLFCRLF(buf) {
+    for (let i = 0; i <= buf.length - 4; i++) {
+        if (buf[i] === 0x0d &&
+            buf[i + 1] === 0x0a &&
+            buf[i + 2] === 0x0d &&
+            buf[i + 3] === 0x0a) {
+            return i;
+        }
+    }
+    return -1;
+}
 export class MCPClient {
     servers = new Map();
     msgId = 1;
@@ -9,39 +48,62 @@ export class MCPClient {
             stdio: ["pipe", "pipe", "pipe"],
             all: false,
         });
-        const state = { process: proc, buffer: "", pending: new Map() };
+        const state = {
+            process: proc,
+            buffer: Buffer.alloc(0),
+            pending: new Map(),
+        };
         this.servers.set(server.id, state);
         proc.stdout?.on("data", (chunk) => {
-            state.buffer += chunk.toString();
-            const lines = state.buffer.split("\n");
-            state.buffer = lines.pop() || "";
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            state.buffer = Buffer.concat([state.buffer, bytes]);
+            for (const raw of parseFrames(state)) {
+                let msg;
                 try {
-                    const msg = JSON.parse(line);
-                    if (msg.id !== undefined) {
-                        const pending = state.pending.get(msg.id);
-                        if (pending) {
-                            state.pending.delete(msg.id);
-                            if (msg.error) {
-                                pending.reject(new Error(msg.error.message));
-                            }
-                            else {
-                                pending.resolve(msg.result);
-                            }
-                        }
-                    }
+                    msg = JSON.parse(raw);
                 }
                 catch {
+                    continue;
                 }
+                if (msg.id !== undefined) {
+                    const pending = state.pending.get(msg.id);
+                    if (pending) {
+                        state.pending.delete(msg.id);
+                        if (msg.error) {
+                            pending.reject(new Error(msg.error.message));
+                        }
+                        else {
+                            pending.resolve(msg.result);
+                        }
+                    }
+                }
+            }
+        });
+        const rejectAll = (reason) => {
+            for (const [id, pending] of state.pending) {
+                state.pending.delete(id);
+                pending.reject(new Error(reason));
             }
+        };
+        proc.on("exit", (code) => {
+            rejectAll(`MCP server exited with code ${code ?? "unknown"}`);
+            this.servers.delete(server.id);
+        });
+        proc.on("error", (err) => {
+            rejectAll(`MCP server process error: ${err.message}`);
+            this.servers.delete(server.id);
         });
         await this.send(server.id, "initialize", {
             protocolVersion: "2024-11-05",
             capabilities: { tools: {}, resources: {} },
             clientInfo: { name: "macha", version: "0.1.0" },
         });
+        const initNotification = {
+            jsonrpc: "2.0",
+            method: "notifications/initialized",
+            params: {},
+        };
+        writeMessage(state, initNotification);
     }
     async send(serverId, method, params) {
         const state = this.servers.get(serverId);
@@ -50,14 +112,23 @@ export class MCPClient {
         const id = this.msgId++;
         const msg = { jsonrpc: "2.0", id, method, params };
         return new Promise((resolve, reject) => {
-            state.pending.set(id, { resolve, reject });
-            state.process.stdin?.write(JSON.stringify(msg) + "\n");
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 if (state.pending.has(id)) {
                     state.pending.delete(id);
-                    reject(new Error("MCP request timed out"));
+                    reject(new Error(`MCP request timed out (method: ${method})`));
                 }
             }, 10000);
+            state.pending.set(id, {
+                resolve: (v) => {
+                    clearTimeout(timer);
+                    resolve(v);
+                },
+                reject: (e) => {
+                    clearTimeout(timer);
+                    reject(e);
+                },
+            });
+            writeMessage(state, msg);
         });
     }
     async listTools(serverId, serverName) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "macha-ai",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A beautiful terminal AI coding assistant — like Claude Code and OpenCode. Supports any OpenAI-compatible provider, MCP servers, file tools, and command execution.",
   "type": "module",
   "bin": {
-    "macha": "./bin/macha.js"
+    "macha": "bin/macha.js"
   },
   "files": [
     "bin/",