pi-usereq 0.6.0 → 0.10.0

package/pi.dev-src/pi-mono/mom/src/store.ts

@@ -0,0 +1,234 @@
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { appendFile, writeFile } from "fs/promises";
+import { join } from "path";
+import * as log from "./log.js";
+
+export interface Attachment {
+	original: string; // original filename from uploader
+	local: string; // path relative to working dir (e.g., "C12345/attachments/1732531234567_file.png")
+}
+
+export interface LoggedMessage {
+	date: string; // ISO 8601 date (e.g., "2025-11-26T10:44:00.000Z") for easy grepping
+	ts: string; // slack timestamp or epoch ms
+	user: string; // user ID (or "bot" for bot responses)
+	userName?: string; // handle (e.g., "mario")
+	displayName?: string; // display name (e.g., "Mario Zechner")
+	text: string;
+	attachments: Attachment[];
+	isBot: boolean;
+}
+
+export interface ChannelStoreConfig {
+	workingDir: string;
+	botToken: string; // needed for authenticated file downloads
+}
+
+interface PendingDownload {
+	channelId: string;
+	localPath: string; // relative path
+	url: string;
+}
+
+export class ChannelStore {
+	private workingDir: string;
+	private botToken: string;
+	private pendingDownloads: PendingDownload[] = [];
+	private isDownloading = false;
+	// Track recently logged message timestamps to prevent duplicates
+	// Key: "channelId:ts", automatically cleaned up after 60 seconds
+	private recentlyLogged = new Map<string, number>();
+
+	constructor(config: ChannelStoreConfig) {
+		this.workingDir = config.workingDir;
+		this.botToken = config.botToken;
+
+		// Ensure working directory exists
+		if (!existsSync(this.workingDir)) {
+			mkdirSync(this.workingDir, { recursive: true });
+		}
+	}
+
+	/**
+	 * Get or create the directory for a channel/DM
+	 */
+	getChannelDir(channelId: string): string {
+		const dir = join(this.workingDir, channelId);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		return dir;
+	}
+
+	/**
+	 * Generate a unique local filename for an attachment
+	 */
+	generateLocalFilename(originalName: string, timestamp: string): string {
+		// Convert slack timestamp (1234567890.123456) to milliseconds
+		const ts = Math.floor(parseFloat(timestamp) * 1000);
+		// Sanitize original name (remove problematic characters)
+		const sanitized = originalName.replace(/[^a-zA-Z0-9._-]/g, "_");
+		return `${ts}_${sanitized}`;
+	}
+
+	/**
+	 * Process attachments from a Slack message event
+	 * Returns attachment metadata and queues downloads
+	 */
+	processAttachments(
+		channelId: string,
+		files: Array<{ name?: string; url_private_download?: string; url_private?: string }>,
+		timestamp: string,
+	): Attachment[] {
+		const attachments: Attachment[] = [];
+
+		for (const file of files) {
+			const url = file.url_private_download || file.url_private;
+			if (!url) continue;
+			if (!file.name) {
+				log.logWarning("Attachment missing name, skipping", url);
+				continue;
+			}
+
+			const filename = this.generateLocalFilename(file.name, timestamp);
+			const localPath = `${channelId}/attachments/${filename}`;
+
+			attachments.push({
+				original: file.name,
+				local: localPath,
+			});
+
+			// Queue for background download
+			this.pendingDownloads.push({ channelId, localPath, url });
+		}
+
+		// Trigger background download
+		this.processDownloadQueue();
+
+		return attachments;
+	}
+
+	/**
+	 * Log a message to the channel's log.jsonl
+	 * Returns false if message was already logged (duplicate)
+	 */
+	async logMessage(channelId: string, message: LoggedMessage): Promise<boolean> {
+		// Check for duplicate (same channel + timestamp)
+		const dedupeKey = `${channelId}:${message.ts}`;
+		if (this.recentlyLogged.has(dedupeKey)) {
+			return false; // Already logged
+		}
+
+		// Mark as logged and schedule cleanup after 60 seconds
+		this.recentlyLogged.set(dedupeKey, Date.now());
+		setTimeout(() => this.recentlyLogged.delete(dedupeKey), 60000);
+
+		const logPath = join(this.getChannelDir(channelId), "log.jsonl");
+
+		// Ensure message has a date field
+		if (!message.date) {
+			// Parse timestamp to get date
+			let date: Date;
+			if (message.ts.includes(".")) {
+				// Slack timestamp format (1234567890.123456)
+				date = new Date(parseFloat(message.ts) * 1000);
+			} else {
+				// Epoch milliseconds
+				date = new Date(parseInt(message.ts, 10));
+			}
+			message.date = date.toISOString();
+		}
+
+		const line = `${JSON.stringify(message)}\n`;
+		await appendFile(logPath, line, "utf-8");
+		return true;
+	}
+
+	/**
+	 * Log a bot response
+	 */
+	async logBotResponse(channelId: string, text: string, ts: string): Promise<void> {
+		await this.logMessage(channelId, {
+			date: new Date().toISOString(),
+			ts,
+			user: "bot",
+			text,
+			attachments: [],
+			isBot: true,
+		});
+	}
+
+	/**
+	 * Get the timestamp of the last logged message for a channel
+	 * Returns null if no log exists
+	 */
+	getLastTimestamp(channelId: string): string | null {
+		const logPath = join(this.workingDir, channelId, "log.jsonl");
+		if (!existsSync(logPath)) {
+			return null;
+		}
+
+		try {
+			const content = readFileSync(logPath, "utf-8");
+			const lines = content.trim().split("\n");
+			if (lines.length === 0 || lines[0] === "") {
+				return null;
+			}
+			const lastLine = lines[lines.length - 1];
+			const message = JSON.parse(lastLine) as LoggedMessage;
+			return message.ts;
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Process the download queue in the background
+	 */
+	private async processDownloadQueue(): Promise<void> {
+		if (this.isDownloading || this.pendingDownloads.length === 0) return;
+
+		this.isDownloading = true;
+
+		while (this.pendingDownloads.length > 0) {
+			const item = this.pendingDownloads.shift();
+			if (!item) break;
+
+			try {
+				await this.downloadAttachment(item.localPath, item.url);
+				// Success - could add success logging here if we have context
+			} catch (error) {
+				const errorMsg = error instanceof Error ? error.message : String(error);
+				log.logWarning(`Failed to download attachment`, `${item.localPath}: ${errorMsg}`);
+			}
+		}
+
+		this.isDownloading = false;
+	}
+
+	/**
+	 * Download a single attachment
+	 */
+	private async downloadAttachment(localPath: string, url: string): Promise<void> {
+		const filePath = join(this.workingDir, localPath);
+
+		// Ensure directory exists
+		const dir = join(this.workingDir, localPath.substring(0, localPath.lastIndexOf("/")));
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+
+		const response = await fetch(url, {
+			headers: {
+				Authorization: `Bearer ${this.botToken}`,
+			},
+		});
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		}
+
+		const buffer = await response.arrayBuffer();
+		await writeFile(filePath, Buffer.from(buffer));
+	}
+}

package/pi.dev-src/pi-mono/mom/src/tools/attach.ts

@@ -0,0 +1,47 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { basename, resolve as resolvePath } from "path";
+import { Type } from "typebox";
+
+// 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. Only files from /workspace/ can be attached.",
+	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,
+		};
+	},
+};

package/pi.dev-src/pi-mono/mom/src/tools/bash.ts

@@ -0,0 +1,97 @@
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Type } from "typebox";
+import type { Executor } from "../sandbox.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateTail } from "./truncate.js";
+
+/**
+ * Generate a unique temp file path for bash output
+ */
+function getTempFilePath(): string {
+	const id = randomBytes(8).toString("hex");
+	return join(tmpdir(), `mom-bash-${id}.log`);
+}
+
+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)" })),
+});
+
+interface BashToolDetails {
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+export function createBashTool(executor: Executor): AgentTool<typeof bashSchema> {
+	return {
+		name: "bash",
+		label: "bash",
+		description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+		parameters: bashSchema,
+		execute: async (
+			_toolCallId: string,
+			{ command, timeout }: { label: string; command: string; timeout?: number },
+			signal?: AbortSignal,
+		) => {
+			// Track output for potential temp file writing
+			let tempFilePath: string | undefined;
+			let tempFileStream: ReturnType<typeof createWriteStream> | undefined;
+
+			const result = await executor.exec(command, { timeout, signal });
+			let output = "";
+			if (result.stdout) output += result.stdout;
+			if (result.stderr) {
+				if (output) output += "\n";
+				output += result.stderr;
+			}
+
+			const totalBytes = Buffer.byteLength(output, "utf-8");
+
+			// Write to temp file if output exceeds limit
+			if (totalBytes > DEFAULT_MAX_BYTES) {
+				tempFilePath = getTempFilePath();
+				tempFileStream = createWriteStream(tempFilePath);
+				tempFileStream.write(output);
+				tempFileStream.end();
+			}
+
+			// Apply tail truncation
+			const truncation = truncateTail(output);
+			let outputText = truncation.content || "(no output)";
+
+			// Build details with truncation info
+			let details: BashToolDetails | undefined;
+
+			if (truncation.truncated) {
+				details = {
+					truncation,
+					fullOutputPath: tempFilePath,
+				};
+
+				// Build actionable notice
+				const startLine = truncation.totalLines - truncation.outputLines + 1;
+				const endLine = truncation.totalLines;
+
+				if (truncation.lastLinePartial) {
+					// Edge case: last line alone > 50KB
+					const lastLineSize = formatSize(Buffer.byteLength(output.split("\n").pop() || "", "utf-8"));
+					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${tempFilePath}]`;
+				} else if (truncation.truncatedBy === "lines") {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+				} else {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+				}
+			}
+
+			if (result.code !== 0) {
+				throw new Error(`${outputText}\n\nCommand exited with code ${result.code}`.trim());
+			}
+
+			return { content: [{ type: "text", text: outputText }], details };
+		},
+	};
+}

package/pi.dev-src/pi-mono/mom/src/tools/edit.ts

@@ -0,0 +1,165 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import * as Diff from "diff";
+import { Type } from "typebox";
+import type { Executor } from "../sandbox.js";
+
+/**
+ * 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) {
+			for (const line of raw) {
+				if (part.added) {
+					const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+					output.push(`+${lineNum} ${line}`);
+					newLineNum++;
+				} else {
+					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+					output.push(`-${lineNum} ${line}`);
+					oldLineNum++;
+				}
+			}
+			lastWasChange = true;
+		} else {
+			const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+
+			if (lastWasChange || nextPartIsChange) {
+				let linesToShow = raw;
+				let skipStart = 0;
+				let skipEnd = 0;
+
+				if (!lastWasChange) {
+					skipStart = Math.max(0, raw.length - contextLines);
+					linesToShow = raw.slice(skipStart);
+				}
+
+				if (!nextPartIsChange && linesToShow.length > contextLines) {
+					skipEnd = linesToShow.length - contextLines;
+					linesToShow = linesToShow.slice(0, contextLines);
+				}
+
+				if (skipStart > 0) {
+					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+				}
+
+				for (const line of linesToShow) {
+					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+					output.push(` ${lineNum} ${line}`);
+					oldLineNum++;
+					newLineNum++;
+				}
+
+				if (skipEnd > 0) {
+					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+				}
+
+				oldLineNum += skipStart + skipEnd;
+				newLineNum += skipStart + skipEnd;
+			} else {
+				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 function createEditTool(executor: Executor): AgentTool<typeof editSchema> {
+	return {
+		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,
+		) => {
+			// Read the file
+			const readResult = await executor.exec(`cat ${shellEscape(path)}`, { signal });
+			if (readResult.code !== 0) {
+				throw new Error(readResult.stderr || `File not found: ${path}`);
+			}
+
+			const content = readResult.stdout;
+
+			// Check if old text exists
+			if (!content.includes(oldText)) {
+				throw new Error(
+					`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`,
+				);
+			}
+
+			// Count occurrences
+			const occurrences = content.split(oldText).length - 1;
+
+			if (occurrences > 1) {
+				throw new Error(
+					`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
+				);
+			}
+
+			// Perform replacement
+			const index = content.indexOf(oldText);
+			const newContent = content.substring(0, index) + newText + content.substring(index + oldText.length);
+
+			if (content === newContent) {
+				throw 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.`,
+				);
+			}
+
+			// Write the file back
+			const writeResult = await executor.exec(`printf '%s' ${shellEscape(newContent)} > ${shellEscape(path)}`, {
+				signal,
+			});
+			if (writeResult.code !== 0) {
+				throw new Error(writeResult.stderr || `Failed to write file: ${path}`);
+			}
+
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Successfully replaced text in ${path}. Changed ${oldText.length} characters to ${newText.length} characters.`,
+					},
+				],
+				details: { diff: generateDiffString(content, newContent) },
+			};
+		},
+	};
+}
+
+function shellEscape(s: string): string {
+	return `'${s.replace(/'/g, "'\\''")}'`;
+}

package/pi.dev-src/pi-mono/mom/src/tools/index.ts

@@ -0,0 +1,19 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { Executor } from "../sandbox.js";
+import { attachTool } from "./attach.js";
+import { createBashTool } from "./bash.js";
+import { createEditTool } from "./edit.js";
+import { createReadTool } from "./read.js";
+import { createWriteTool } from "./write.js";
+
+export { setUploadFunction } from "./attach.js";
+
+export function createMomTools(executor: Executor): AgentTool<any>[] {
+	return [
+		createReadTool(executor),
+		createBashTool(executor),
+		createEditTool(executor),
+		createWriteTool(executor),
+		attachTool,
+	];
+}