mom: Slack bot with abort support, streaming console output, removed sandbox

packages/mom/src/tools/attach.ts

@@ -0,0 +1,46 @@
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { basename, resolve as resolvePath } from "path";
+
+// This will be set by the agent before running
+let uploadFn: ((filePath: string, title?: string) => Promise<void>) | null = null;
+
+export function setUploadFunction(fn: (filePath: string, title?: string) => Promise<void>): void {
+	uploadFn = fn;
+}
+
+const attachSchema = Type.Object({
+	label: Type.String({ description: "Brief description of what you're sharing (shown to user)" }),
+	path: Type.String({ description: "Path to the file to attach" }),
+	title: Type.Optional(Type.String({ description: "Title for the file (defaults to filename)" })),
+});
+
+export const attachTool: AgentTool<typeof attachSchema> = {
+	name: "attach",
+	label: "attach",
+	description: "Attach a file to your response. Use this to share files, images, or documents with the user.",
+	parameters: attachSchema,
+	execute: async (
+		_toolCallId: string,
+		{ path, title }: { label: string; path: string; title?: string },
+		signal?: AbortSignal,
+	) => {
+		if (!uploadFn) {
+			throw new Error("Upload function not configured");
+		}
+
+		if (signal?.aborted) {
+			throw new Error("Operation aborted");
+		}
+
+		const absolutePath = resolvePath(path);
+		const fileName = title || basename(absolutePath);
+
+		await uploadFn(absolutePath, fileName);
+
+		return {
+			content: [{ type: "text" as const, text: `Attached file: ${fileName}` }],
+			details: undefined,
+		};
+	},
+};

packages/mom/src/tools/bash.ts

@@ -0,0 +1,189 @@
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+
+/**
+ * Get shell configuration based on platform
+ */
+function getShellConfig(): { shell: string; args: string[] } {
+	if (process.platform === "win32") {
+		const paths: string[] = [];
+		const programFiles = process.env.ProgramFiles;
+		if (programFiles) {
+			paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+		}
+		const programFilesX86 = process.env["ProgramFiles(x86)"];
+		if (programFilesX86) {
+			paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+		}
+
+		for (const path of paths) {
+			if (existsSync(path)) {
+				return { shell: path, args: ["-c"] };
+			}
+		}
+
+		throw new Error(
+			`Git Bash not found. Please install Git for Windows from https://git-scm.com/download/win\n` +
+				`Searched in:\n${paths.map((p) => `  ${p}`).join("\n")}`,
+		);
+	}
+	return { shell: "sh", args: ["-c"] };
+}
+
+/**
+ * Kill a process and all its children
+ */
+function killProcessTree(pid: number): void {
+	if (process.platform === "win32") {
+		// Use taskkill on Windows to kill process tree
+		try {
+			spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+				stdio: "ignore",
+				detached: true,
+			});
+		} catch {
+			// Ignore errors if taskkill fails
+		}
+	} else {
+		// Use SIGKILL on Unix/Linux/Mac
+		try {
+			process.kill(-pid, "SIGKILL");
+		} catch {
+			// Fallback to killing just the child if process group kill fails
+			try {
+				process.kill(pid, "SIGKILL");
+			} catch {
+				// Process already dead
+			}
+		}
+	}
+}
+
+const bashSchema = Type.Object({
+	label: Type.String({ description: "Brief description of what this command does (shown to user)" }),
+	command: Type.String({ description: "Bash command to execute" }),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+
+export const bashTool: AgentTool<typeof bashSchema> = {
+	name: "bash",
+	label: "bash",
+	description:
+		"Execute a bash command in the current working directory. Returns stdout and stderr. Optionally provide a timeout in seconds.",
+	parameters: bashSchema,
+	execute: async (
+		_toolCallId: string,
+		{ command, timeout }: { label: string; command: string; timeout?: number },
+		signal?: AbortSignal,
+	) => {
+		return new Promise((resolve, reject) => {
+			const { shell, args } = getShellConfig();
+			const child = spawn(shell, [...args, command], {
+				detached: true,
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+
+			let stdout = "";
+			let stderr = "";
+			let timedOut = false;
+
+			// Set timeout if provided
+			let timeoutHandle: NodeJS.Timeout | undefined;
+			if (timeout !== undefined && timeout > 0) {
+				timeoutHandle = setTimeout(() => {
+					timedOut = true;
+					onAbort();
+				}, timeout * 1000);
+			}
+
+			// Collect stdout
+			if (child.stdout) {
+				child.stdout.on("data", (data) => {
+					stdout += data.toString();
+					// Limit buffer size
+					if (stdout.length > 10 * 1024 * 1024) {
+						stdout = stdout.slice(0, 10 * 1024 * 1024);
+					}
+				});
+			}
+
+			// Collect stderr
+			if (child.stderr) {
+				child.stderr.on("data", (data) => {
+					stderr += data.toString();
+					// Limit buffer size
+					if (stderr.length > 10 * 1024 * 1024) {
+						stderr = stderr.slice(0, 10 * 1024 * 1024);
+					}
+				});
+			}
+
+			// Handle process exit
+			child.on("close", (code) => {
+				if (timeoutHandle) {
+					clearTimeout(timeoutHandle);
+				}
+				if (signal) {
+					signal.removeEventListener("abort", onAbort);
+				}
+
+				if (signal?.aborted) {
+					let output = "";
+					if (stdout) output += stdout;
+					if (stderr) {
+						if (output) output += "\n";
+						output += stderr;
+					}
+					if (output) output += "\n\n";
+					output += "Command aborted";
+					reject(new Error(output));
+					return;
+				}
+
+				if (timedOut) {
+					let output = "";
+					if (stdout) output += stdout;
+					if (stderr) {
+						if (output) output += "\n";
+						output += stderr;
+					}
+					if (output) output += "\n\n";
+					output += `Command timed out after ${timeout} seconds`;
+					reject(new Error(output));
+					return;
+				}
+
+				let output = "";
+				if (stdout) output += stdout;
+				if (stderr) {
+					if (output) output += "\n";
+					output += stderr;
+				}
+
+				if (code !== 0 && code !== null) {
+					if (output) output += "\n\n";
+					reject(new Error(`${output}Command exited with code ${code}`));
+				} else {
+					resolve({ content: [{ type: "text", text: output || "(no output)" }], details: undefined });
+				}
+			});
+
+			// Handle abort signal - kill entire process tree
+			const onAbort = () => {
+				if (child.pid) {
+					killProcessTree(child.pid);
+				}
+			};
+
+			if (signal) {
+				if (signal.aborted) {
+					onAbort();
+				} else {
+					signal.addEventListener("abort", onAbort, { once: true });
+				}
+			}
+		});
+	},
+};

packages/mom/src/tools/edit.ts

@@ -0,0 +1,269 @@
+import * as os from "node:os";
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import * as Diff from "diff";
+import { constants } from "fs";
+import { access, readFile, writeFile } from "fs/promises";
+import { resolve as resolvePath } from "path";
+
+/**
+ * Expand ~ to home directory
+ */
+function expandPath(filePath: string): string {
+	if (filePath === "~") {
+		return os.homedir();
+	}
+	if (filePath.startsWith("~/")) {
+		return os.homedir() + filePath.slice(1);
+	}
+	return filePath;
+}
+
+/**
+ * Generate a unified diff string with line numbers and context
+ */
+function generateDiffString(oldContent: string, newContent: string, contextLines = 4): string {
+	const parts = Diff.diffLines(oldContent, newContent);
+	const output: string[] = [];
+
+	const oldLines = oldContent.split("\n");
+	const newLines = newContent.split("\n");
+	const maxLineNum = Math.max(oldLines.length, newLines.length);
+	const lineNumWidth = String(maxLineNum).length;
+
+	let oldLineNum = 1;
+	let newLineNum = 1;
+	let lastWasChange = false;
+
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		const raw = part.value.split("\n");
+		if (raw[raw.length - 1] === "") {
+			raw.pop();
+		}
+
+		if (part.added || part.removed) {
+			// Show the change
+			for (const line of raw) {
+				if (part.added) {
+					const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+					output.push(`+${lineNum} ${line}`);
+					newLineNum++;
+				} else {
+					// removed
+					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+					output.push(`-${lineNum} ${line}`);
+					oldLineNum++;
+				}
+			}
+			lastWasChange = true;
+		} else {
+			// Context lines - only show a few before/after changes
+			const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+
+			if (lastWasChange || nextPartIsChange) {
+				// Show context
+				let linesToShow = raw;
+				let skipStart = 0;
+				let skipEnd = 0;
+
+				if (!lastWasChange) {
+					// Show only last N lines as leading context
+					skipStart = Math.max(0, raw.length - contextLines);
+					linesToShow = raw.slice(skipStart);
+				}
+
+				if (!nextPartIsChange && linesToShow.length > contextLines) {
+					// Show only first N lines as trailing context
+					skipEnd = linesToShow.length - contextLines;
+					linesToShow = linesToShow.slice(0, contextLines);
+				}
+
+				// Add ellipsis if we skipped lines at start
+				if (skipStart > 0) {
+					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+				}
+
+				for (const line of linesToShow) {
+					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+					output.push(` ${lineNum} ${line}`);
+					oldLineNum++;
+					newLineNum++;
+				}
+
+				// Add ellipsis if we skipped lines at end
+				if (skipEnd > 0) {
+					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+				}
+
+				// Update line numbers for skipped lines
+				oldLineNum += skipStart + skipEnd;
+				newLineNum += skipStart + skipEnd;
+			} else {
+				// Skip these context lines entirely
+				oldLineNum += raw.length;
+				newLineNum += raw.length;
+			}
+
+			lastWasChange = false;
+		}
+	}
+
+	return output.join("\n");
+}
+
+const editSchema = Type.Object({
+	label: Type.String({ description: "Brief description of the edit you're making (shown to user)" }),
+	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+	oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
+	newText: Type.String({ description: "New text to replace the old text with" }),
+});
+
+export const editTool: AgentTool<typeof editSchema> = {
+	name: "edit",
+	label: "edit",
+	description:
+		"Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+	parameters: editSchema,
+	execute: async (
+		_toolCallId: string,
+		{ path, oldText, newText }: { label: string; path: string; oldText: string; newText: string },
+		signal?: AbortSignal,
+	) => {
+		const absolutePath = resolvePath(expandPath(path));
+
+		return new Promise<{
+			content: Array<{ type: "text"; text: string }>;
+			details: { diff: string } | undefined;
+		}>((resolve, reject) => {
+			// Check if already aborted
+			if (signal?.aborted) {
+				reject(new Error("Operation aborted"));
+				return;
+			}
+
+			let aborted = false;
+
+			// Set up abort handler
+			const onAbort = () => {
+				aborted = true;
+				reject(new Error("Operation aborted"));
+			};
+
+			if (signal) {
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+
+			// Perform the edit operation
+			(async () => {
+				try {
+					// Check if file exists
+					try {
+						await access(absolutePath, constants.R_OK | constants.W_OK);
+					} catch {
+						if (signal) {
+							signal.removeEventListener("abort", onAbort);
+						}
+						reject(new Error(`File not found: ${path}`));
+						return;
+					}
+
+					// Check if aborted before reading
+					if (aborted) {
+						return;
+					}
+
+					// Read the file
+					const content = await readFile(absolutePath, "utf-8");
+
+					// Check if aborted after reading
+					if (aborted) {
+						return;
+					}
+
+					// Check if old text exists
+					if (!content.includes(oldText)) {
+						if (signal) {
+							signal.removeEventListener("abort", onAbort);
+						}
+						reject(
+							new Error(
+								`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`,
+							),
+						);
+						return;
+					}
+
+					// Count occurrences
+					const occurrences = content.split(oldText).length - 1;
+
+					if (occurrences > 1) {
+						if (signal) {
+							signal.removeEventListener("abort", onAbort);
+						}
+						reject(
+							new Error(
+								`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
+							),
+						);
+						return;
+					}
+
+					// Check if aborted before writing
+					if (aborted) {
+						return;
+					}
+
+					// Perform replacement using indexOf + substring (raw string replace, no special character interpretation)
+					// String.replace() interprets $ in the replacement string, so we do manual replacement
+					const index = content.indexOf(oldText);
+					const newContent = content.substring(0, index) + newText + content.substring(index + oldText.length);
+
+					// Verify the replacement actually changed something
+					if (content === newContent) {
+						if (signal) {
+							signal.removeEventListener("abort", onAbort);
+						}
+						reject(
+							new Error(
+								`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`,
+							),
+						);
+						return;
+					}
+
+					await writeFile(absolutePath, newContent, "utf-8");
+
+					// Check if aborted after writing
+					if (aborted) {
+						return;
+					}
+
+					// Clean up abort handler
+					if (signal) {
+						signal.removeEventListener("abort", onAbort);
+					}
+
+					resolve({
+						content: [
+							{
+								type: "text",
+								text: `Successfully replaced text in ${path}. Changed ${oldText.length} characters to ${newText.length} characters.`,
+							},
+						],
+						details: { diff: generateDiffString(content, newContent) },
+					});
+				} catch (error: unknown) {
+					// Clean up abort handler
+					if (signal) {
+						signal.removeEventListener("abort", onAbort);
+					}
+
+					if (!aborted) {
+						reject(error);
+					}
+				}
+			})();
+		});
+	},
+};

packages/mom/src/tools/index.ts

@@ -0,0 +1,13 @@
+export { attachTool, setUploadFunction } from "./attach.js";
+export { bashTool } from "./bash.js";
+export { editTool } from "./edit.js";
+export { readTool } from "./read.js";
+export { writeTool } from "./write.js";
+
+import { attachTool } from "./attach.js";
+import { bashTool } from "./bash.js";
+import { editTool } from "./edit.js";
+import { readTool } from "./read.js";
+import { writeTool } from "./write.js";
+
+export const momTools = [readTool, bashTool, editTool, writeTool, attachTool];

packages/mom/src/tools/read.ts

@@ -0,0 +1,179 @@
+import * as os from "node:os";
+import type { AgentTool, ImageContent, TextContent } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { access, readFile } from "fs/promises";
+import { extname, resolve as resolvePath } from "path";
+
+/**
+ * Expand ~ to home directory
+ */
+function expandPath(filePath: string): string {
+	if (filePath === "~") {
+		return os.homedir();
+	}
+	if (filePath.startsWith("~/")) {
+		return os.homedir() + filePath.slice(1);
+	}
+	return filePath;
+}
+
+/**
+ * Map of file extensions to MIME types for common image formats
+ */
+const IMAGE_MIME_TYPES: Record<string, string> = {
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".png": "image/png",
+	".gif": "image/gif",
+	".webp": "image/webp",
+};
+
+/**
+ * Check if a file is an image based on its extension
+ */
+function isImageFile(filePath: string): string | null {
+	const ext = extname(filePath).toLowerCase();
+	return IMAGE_MIME_TYPES[ext] || null;
+}
+
+const readSchema = Type.Object({
+	label: Type.String({ description: "Brief description of what you're reading and why (shown to user)" }),
+	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+});
+
+const MAX_LINES = 2000;
+const MAX_LINE_LENGTH = 2000;
+
+export const readTool: AgentTool<typeof readSchema> = {
+	name: "read",
+	label: "read",
+	description:
+		"Read the contents of a file. Supports text files and images (jpg, png, gif, webp). Images are sent as attachments. For text files, defaults to first 2000 lines. Use offset/limit for large files.",
+	parameters: readSchema,
+	execute: async (
+		_toolCallId: string,
+		{ path, offset, limit }: { label: string; path: string; offset?: number; limit?: number },
+		signal?: AbortSignal,
+	) => {
+		const absolutePath = resolvePath(expandPath(path));
+		const mimeType = isImageFile(absolutePath);
+
+		return new Promise<{ content: (TextContent | ImageContent)[]; details: undefined }>((resolve, reject) => {
+			// Check if already aborted
+			if (signal?.aborted) {
+				reject(new Error("Operation aborted"));
+				return;
+			}
+
+			let aborted = false;
+
+			// Set up abort handler
+			const onAbort = () => {
+				aborted = true;
+				reject(new Error("Operation aborted"));
+			};
+
+			if (signal) {
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+
+			// Perform the read operation
+			(async () => {
+				try {
+					// Check if file exists
+					await access(absolutePath, constants.R_OK);
+
+					// Check if aborted before reading
+					if (aborted) {
+						return;
+					}
+
+					// Read the file based on type
+					let content: (TextContent | ImageContent)[];
+
+					if (mimeType) {
+						// Read as image (binary)
+						const buffer = await readFile(absolutePath);
+						const base64 = buffer.toString("base64");
+
+						content = [
+							{ type: "text", text: `Read image file [${mimeType}]` },
+							{ type: "image", data: base64, mimeType },
+						];
+					} else {
+						// Read as text
+						const textContent = await readFile(absolutePath, "utf-8");
+						const lines = textContent.split("\n");
+
+						// Apply offset and limit (matching Claude Code Read tool behavior)
+						const startLine = offset ? Math.max(0, offset - 1) : 0; // 1-indexed to 0-indexed
+						const maxLines = limit || MAX_LINES;
+						const endLine = Math.min(startLine + maxLines, lines.length);
+
+						// Check if offset is out of bounds
+						if (startLine >= lines.length) {
+							throw new Error(`Offset ${offset} is beyond end of file (${lines.length} lines total)`);
+						}
+
+						// Get the relevant lines
+						const selectedLines = lines.slice(startLine, endLine);
+
+						// Truncate long lines and track which were truncated
+						let hadTruncatedLines = false;
+						const formattedLines = selectedLines.map((line) => {
+							if (line.length > MAX_LINE_LENGTH) {
+								hadTruncatedLines = true;
+								return line.slice(0, MAX_LINE_LENGTH);
+							}
+							return line;
+						});
+
+						let outputText = formattedLines.join("\n");
+
+						// Add notices
+						const notices: string[] = [];
+
+						if (hadTruncatedLines) {
+							notices.push(`Some lines were truncated to ${MAX_LINE_LENGTH} characters for display`);
+						}
+
+						if (endLine < lines.length) {
+							const remaining = lines.length - endLine;
+							notices.push(`${remaining} more lines not shown. Use offset=${endLine + 1} to continue reading`);
+						}
+
+						if (notices.length > 0) {
+							outputText += `\n\n... (${notices.join(". ")})`;
+						}
+
+						content = [{ type: "text", text: outputText }];
+					}
+
+					// Check if aborted after reading
+					if (aborted) {
+						return;
+					}
+
+					// Clean up abort handler
+					if (signal) {
+						signal.removeEventListener("abort", onAbort);
+					}
+
+					resolve({ content, details: undefined });
+				} catch (error: unknown) {
+					// Clean up abort handler
+					if (signal) {
+						signal.removeEventListener("abort", onAbort);
+					}
+
+					if (!aborted) {
+						reject(error);
+					}
+				}
+			})();
+		});
+	},
+};

packages/mom/src/tools/write.ts

@@ -0,0 +1,100 @@
+import * as os from "node:os";
+import type { AgentTool } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve as resolvePath } from "path";
+
+/**
+ * Expand ~ to home directory
+ */
+function expandPath(filePath: string): string {
+	if (filePath === "~") {
+		return os.homedir();
+	}
+	if (filePath.startsWith("~/")) {
+		return os.homedir() + filePath.slice(1);
+	}
+	return filePath;
+}
+
+const writeSchema = Type.Object({
+	label: Type.String({ description: "Brief description of what you're writing (shown to user)" }),
+	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+	content: Type.String({ description: "Content to write to the file" }),
+});
+
+export const writeTool: AgentTool<typeof writeSchema> = {
+	name: "write",
+	label: "write",
+	description:
+		"Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+	parameters: writeSchema,
+	execute: async (
+		_toolCallId: string,
+		{ path, content }: { label: string; path: string; content: string },
+		signal?: AbortSignal,
+	) => {
+		const absolutePath = resolvePath(expandPath(path));
+		const dir = dirname(absolutePath);
+
+		return new Promise<{ content: Array<{ type: "text"; text: string }>; details: undefined }>((resolve, reject) => {
+			// Check if already aborted
+			if (signal?.aborted) {
+				reject(new Error("Operation aborted"));
+				return;
+			}
+
+			let aborted = false;
+
+			// Set up abort handler
+			const onAbort = () => {
+				aborted = true;
+				reject(new Error("Operation aborted"));
+			};
+
+			if (signal) {
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+
+			// Perform the write operation
+			(async () => {
+				try {
+					// Create parent directories if needed
+					await mkdir(dir, { recursive: true });
+
+					// Check if aborted before writing
+					if (aborted) {
+						return;
+					}
+
+					// Write the file
+					await writeFile(absolutePath, content, "utf-8");
+
+					// Check if aborted after writing
+					if (aborted) {
+						return;
+					}
+
+					// Clean up abort handler
+					if (signal) {
+						signal.removeEventListener("abort", onAbort);
+					}
+
+					resolve({
+						content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
+						details: undefined,
+					});
+				} catch (error: unknown) {
+					// Clean up abort handler
+					if (signal) {
+						signal.removeEventListener("abort", onAbort);
+					}
+
+					if (!aborted) {
+						reject(error);
+					}
+				}
+			})();
+		});
+	},
+};