pi-usereq 0.7.0 → 0.10.0

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

@@ -0,0 +1,271 @@
+import chalk from "chalk";
+
+export interface LogContext {
+	channelId: string;
+	userName?: string;
+	channelName?: string; // For display like #dev-team vs C16HET4EQ
+}
+
+function timestamp(): string {
+	const now = new Date();
+	const hh = String(now.getHours()).padStart(2, "0");
+	const mm = String(now.getMinutes()).padStart(2, "0");
+	const ss = String(now.getSeconds()).padStart(2, "0");
+	return `[${hh}:${mm}:${ss}]`;
+}
+
+function formatContext(ctx: LogContext): string {
+	// DMs: [DM:username]
+	// Channels: [#channel-name:username] or [C16HET4EQ:username] if no name
+	if (ctx.channelId.startsWith("D")) {
+		return `[DM:${ctx.userName || ctx.channelId}]`;
+	}
+	const channel = ctx.channelName || ctx.channelId;
+	const user = ctx.userName || "unknown";
+	return `[${channel.startsWith("#") ? channel : `#${channel}`}:${user}]`;
+}
+
+function truncate(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return `${text.substring(0, maxLen)}\n(truncated at ${maxLen} chars)`;
+}
+
+function formatToolArgs(args: Record<string, unknown>): string {
+	const lines: string[] = [];
+
+	for (const [key, value] of Object.entries(args)) {
+		// Skip the label - it's already shown in the tool name
+		if (key === "label") continue;
+
+		// For read tool, format path with offset/limit
+		if (key === "path" && typeof value === "string") {
+			const offset = args.offset as number | undefined;
+			const limit = args.limit as number | undefined;
+			if (offset !== undefined && limit !== undefined) {
+				lines.push(`${value}:${offset}-${offset + limit}`);
+			} else {
+				lines.push(value);
+			}
+			continue;
+		}
+
+		// Skip offset/limit since we already handled them
+		if (key === "offset" || key === "limit") continue;
+
+		// For other values, format them
+		if (typeof value === "string") {
+			// Multi-line strings get indented
+			if (value.includes("\n")) {
+				lines.push(value);
+			} else {
+				lines.push(value);
+			}
+		} else {
+			lines.push(JSON.stringify(value));
+		}
+	}
+
+	return lines.join("\n");
+}
+
+// User messages
+export function logUserMessage(ctx: LogContext, text: string): void {
+	console.log(chalk.green(`${timestamp()} ${formatContext(ctx)} ${text}`));
+}
+
+// Tool execution
+export function logToolStart(ctx: LogContext, toolName: string, label: string, args: Record<string, unknown>): void {
+	const formattedArgs = formatToolArgs(args);
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ↳ ${toolName}: ${label}`));
+	if (formattedArgs) {
+		// Indent the args
+		const indented = formattedArgs
+			.split("\n")
+			.map((line) => `           ${line}`)
+			.join("\n");
+		console.log(chalk.dim(indented));
+	}
+}
+
+export function logToolSuccess(ctx: LogContext, toolName: string, durationMs: number, result: string): void {
+	const duration = (durationMs / 1000).toFixed(1);
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ✓ ${toolName} (${duration}s)`));
+
+	const truncated = truncate(result, 1000);
+	if (truncated) {
+		const indented = truncated
+			.split("\n")
+			.map((line) => `           ${line}`)
+			.join("\n");
+		console.log(chalk.dim(indented));
+	}
+}
+
+export function logToolError(ctx: LogContext, toolName: string, durationMs: number, error: string): void {
+	const duration = (durationMs / 1000).toFixed(1);
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ✗ ${toolName} (${duration}s)`));
+
+	const truncated = truncate(error, 1000);
+	const indented = truncated
+		.split("\n")
+		.map((line) => `           ${line}`)
+		.join("\n");
+	console.log(chalk.dim(indented));
+}
+
+// Response streaming
+export function logResponseStart(ctx: LogContext): void {
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} → Streaming response...`));
+}
+
+export function logThinking(ctx: LogContext, thinking: string): void {
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} 💭 Thinking`));
+	const truncated = truncate(thinking, 1000);
+	const indented = truncated
+		.split("\n")
+		.map((line) => `           ${line}`)
+		.join("\n");
+	console.log(chalk.dim(indented));
+}
+
+export function logResponse(ctx: LogContext, text: string): void {
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} 💬 Response`));
+	const truncated = truncate(text, 1000);
+	const indented = truncated
+		.split("\n")
+		.map((line) => `           ${line}`)
+		.join("\n");
+	console.log(chalk.dim(indented));
+}
+
+// Attachments
+export function logDownloadStart(ctx: LogContext, filename: string, localPath: string): void {
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ↓ Downloading attachment`));
+	console.log(chalk.dim(`           ${filename} → ${localPath}`));
+}
+
+export function logDownloadSuccess(ctx: LogContext, sizeKB: number): void {
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ✓ Downloaded (${sizeKB.toLocaleString()} KB)`));
+}
+
+export function logDownloadError(ctx: LogContext, filename: string, error: string): void {
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ✗ Download failed`));
+	console.log(chalk.dim(`           ${filename}: ${error}`));
+}
+
+// Control
+export function logStopRequest(ctx: LogContext): void {
+	console.log(chalk.green(`${timestamp()} ${formatContext(ctx)} stop`));
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} ⊗ Stop requested - aborting`));
+}
+
+// System
+export function logInfo(message: string): void {
+	console.log(chalk.blue(`${timestamp()} [system] ${message}`));
+}
+
+export function logWarning(message: string, details?: string): void {
+	console.log(chalk.yellow(`${timestamp()} [system] ⚠ ${message}`));
+	if (details) {
+		const indented = details
+			.split("\n")
+			.map((line) => `           ${line}`)
+			.join("\n");
+		console.log(chalk.dim(indented));
+	}
+}
+
+export function logAgentError(ctx: LogContext | "system", error: string): void {
+	const context = ctx === "system" ? "[system]" : formatContext(ctx);
+	console.log(chalk.yellow(`${timestamp()} ${context} ✗ Agent error`));
+	const indented = error
+		.split("\n")
+		.map((line) => `           ${line}`)
+		.join("\n");
+	console.log(chalk.dim(indented));
+}
+
+// Usage summary
+export function logUsageSummary(
+	ctx: LogContext,
+	usage: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+		cost: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number };
+	},
+	contextTokens?: number,
+	contextWindow?: number,
+): string {
+	const formatTokens = (count: number): string => {
+		if (count < 1000) return count.toString();
+		if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+		if (count < 1000000) return `${Math.round(count / 1000)}k`;
+		return `${(count / 1000000).toFixed(1)}M`;
+	};
+
+	const lines: string[] = [];
+	lines.push("*Usage Summary*");
+	lines.push(`Tokens: ${usage.input.toLocaleString()} in, ${usage.output.toLocaleString()} out`);
+	if (usage.cacheRead > 0 || usage.cacheWrite > 0) {
+		lines.push(`Cache: ${usage.cacheRead.toLocaleString()} read, ${usage.cacheWrite.toLocaleString()} write`);
+	}
+	if (contextTokens && contextWindow) {
+		const contextPercent = ((contextTokens / contextWindow) * 100).toFixed(1);
+		lines.push(`Context: ${formatTokens(contextTokens)} / ${formatTokens(contextWindow)} (${contextPercent}%)`);
+	}
+	lines.push(
+		`Cost: $${usage.cost.input.toFixed(4)} in, $${usage.cost.output.toFixed(4)} out` +
+			(usage.cacheRead > 0 || usage.cacheWrite > 0
+				? `, $${usage.cost.cacheRead.toFixed(4)} cache read, $${usage.cost.cacheWrite.toFixed(4)} cache write`
+				: ""),
+	);
+	lines.push(`*Total: $${usage.cost.total.toFixed(4)}*`);
+
+	const summary = lines.join("\n");
+
+	// Log to console
+	console.log(chalk.yellow(`${timestamp()} ${formatContext(ctx)} 💰 Usage`));
+	console.log(
+		chalk.dim(
+			`           ${usage.input.toLocaleString()} in + ${usage.output.toLocaleString()} out` +
+				(usage.cacheRead > 0 || usage.cacheWrite > 0
+					? ` (${usage.cacheRead.toLocaleString()} cache read, ${usage.cacheWrite.toLocaleString()} cache write)`
+					: "") +
+				` = $${usage.cost.total.toFixed(4)}`,
+		),
+	);
+
+	return summary;
+}
+
+// Startup (no context needed)
+export function logStartup(workingDir: string, sandbox: string): void {
+	console.log("Starting mom bot...");
+	console.log(`  Working directory: ${workingDir}`);
+	console.log(`  Sandbox: ${sandbox}`);
+}
+
+export function logConnected(): void {
+	console.log("⚡️ Mom bot connected and listening!");
+	console.log("");
+}
+
+export function logDisconnected(): void {
+	console.log("Mom bot disconnected.");
+}
+
+// Backfill
+export function logBackfillStart(channelCount: number): void {
+	console.log(chalk.blue(`${timestamp()} [system] Backfilling ${channelCount} channels...`));
+}
+
+export function logBackfillChannel(channelName: string, messageCount: number): void {
+	console.log(chalk.blue(`${timestamp()} [system]   #${channelName}: ${messageCount} messages`));
+}
+
+export function logBackfillComplete(totalMessages: number, durationMs: number): void {
+	const duration = (durationMs / 1000).toFixed(1);
+	console.log(chalk.blue(`${timestamp()} [system] Backfill complete: ${totalMessages} messages in ${duration}s`));
+}

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

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+import { join, resolve } from "path";
+import { type AgentRunner, getOrCreateRunner } from "./agent.js";
+import { downloadChannel } from "./download.js";
+import { createEventsWatcher } from "./events.js";
+import * as log from "./log.js";
+import { parseSandboxArg, type SandboxConfig, validateSandbox } from "./sandbox.js";
+import { type MomHandler, type SlackBot, SlackBot as SlackBotClass, type SlackEvent } from "./slack.js";
+import { ChannelStore } from "./store.js";
+
+// ============================================================================
+// Config
+// ============================================================================
+
+const MOM_SLACK_APP_TOKEN = process.env.MOM_SLACK_APP_TOKEN;
+const MOM_SLACK_BOT_TOKEN = process.env.MOM_SLACK_BOT_TOKEN;
+
+interface ParsedArgs {
+	workingDir?: string;
+	sandbox: SandboxConfig;
+	downloadChannel?: string;
+}
+
+function parseArgs(): ParsedArgs {
+	const args = process.argv.slice(2);
+	let sandbox: SandboxConfig = { type: "host" };
+	let workingDir: string | undefined;
+	let downloadChannelId: string | undefined;
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--sandbox=")) {
+			sandbox = parseSandboxArg(arg.slice("--sandbox=".length));
+		} else if (arg === "--sandbox") {
+			sandbox = parseSandboxArg(args[++i] || "");
+		} else if (arg.startsWith("--download=")) {
+			downloadChannelId = arg.slice("--download=".length);
+		} else if (arg === "--download") {
+			downloadChannelId = args[++i];
+		} else if (!arg.startsWith("-")) {
+			workingDir = arg;
+		}
+	}
+
+	return {
+		workingDir: workingDir ? resolve(workingDir) : undefined,
+		sandbox,
+		downloadChannel: downloadChannelId,
+	};
+}
+
+const parsedArgs = parseArgs();
+
+// Handle --download mode
+if (parsedArgs.downloadChannel) {
+	if (!MOM_SLACK_BOT_TOKEN) {
+		console.error("Missing env: MOM_SLACK_BOT_TOKEN");
+		process.exit(1);
+	}
+	await downloadChannel(parsedArgs.downloadChannel, MOM_SLACK_BOT_TOKEN);
+	process.exit(0);
+}
+
+// Normal bot mode - require working dir
+if (!parsedArgs.workingDir) {
+	console.error("Usage: mom [--sandbox=host|docker:<name>] <working-directory>");
+	console.error("       mom --download <channel-id>");
+	process.exit(1);
+}
+
+const { workingDir, sandbox } = { workingDir: parsedArgs.workingDir, sandbox: parsedArgs.sandbox };
+
+if (!MOM_SLACK_APP_TOKEN || !MOM_SLACK_BOT_TOKEN) {
+	console.error("Missing env: MOM_SLACK_APP_TOKEN, MOM_SLACK_BOT_TOKEN");
+	process.exit(1);
+}
+
+await validateSandbox(sandbox);
+
+// ============================================================================
+// State (per channel)
+// ============================================================================
+
+interface ChannelState {
+	running: boolean;
+	runner: AgentRunner;
+	store: ChannelStore;
+	stopRequested: boolean;
+	stopMessageTs?: string;
+}
+
+const channelStates = new Map<string, ChannelState>();
+
+function getState(channelId: string): ChannelState {
+	let state = channelStates.get(channelId);
+	if (!state) {
+		const channelDir = join(workingDir, channelId);
+		state = {
+			running: false,
+			runner: getOrCreateRunner(sandbox, channelId, channelDir),
+			store: new ChannelStore({ workingDir, botToken: MOM_SLACK_BOT_TOKEN! }),
+			stopRequested: false,
+		};
+		channelStates.set(channelId, state);
+	}
+	return state;
+}
+
+// ============================================================================
+// Create SlackContext adapter
+// ============================================================================
+
+function createSlackContext(event: SlackEvent, slack: SlackBot, state: ChannelState, isEvent?: boolean) {
+	let messageTs: string | null = null;
+	const threadMessageTs: string[] = [];
+	let accumulatedText = "";
+	let isWorking = true;
+	const workingIndicator = " ...";
+	let updatePromise = Promise.resolve();
+
+	const user = slack.getUser(event.user);
+
+	// Extract event filename for status message
+	const eventFilename = isEvent ? event.text.match(/^\[EVENT:([^:]+):/)?.[1] : undefined;
+
+	return {
+		message: {
+			text: event.text,
+			rawText: event.text,
+			user: event.user,
+			userName: user?.userName,
+			channel: event.channel,
+			ts: event.ts,
+			attachments: (event.attachments || []).map((a) => ({ local: a.local })),
+		},
+		channelName: slack.getChannel(event.channel)?.name,
+		store: state.store,
+		channels: slack.getAllChannels().map((c) => ({ id: c.id, name: c.name })),
+		users: slack.getAllUsers().map((u) => ({ id: u.id, userName: u.userName, displayName: u.displayName })),
+
+		respond: async (text: string, shouldLog = true) => {
+			updatePromise = updatePromise.then(async () => {
+				try {
+					accumulatedText = accumulatedText ? `${accumulatedText}\n${text}` : text;
+
+					// Truncate accumulated text if too long (Slack limit is 40K, we use 35K for safety)
+					const MAX_MAIN_LENGTH = 35000;
+					const truncationNote = "\n\n_(message truncated, ask me to elaborate on specific parts)_";
+					if (accumulatedText.length > MAX_MAIN_LENGTH) {
+						accumulatedText =
+							accumulatedText.substring(0, MAX_MAIN_LENGTH - truncationNote.length) + truncationNote;
+					}
+
+					const displayText = isWorking ? accumulatedText + workingIndicator : accumulatedText;
+
+					if (messageTs) {
+						await slack.updateMessage(event.channel, messageTs, displayText);
+					} else {
+						messageTs = await slack.postMessage(event.channel, displayText);
+					}
+
+					if (shouldLog && messageTs) {
+						slack.logBotResponse(event.channel, text, messageTs);
+					}
+				} catch (err) {
+					log.logWarning("Slack respond error", err instanceof Error ? err.message : String(err));
+				}
+			});
+			await updatePromise;
+		},
+
+		replaceMessage: async (text: string) => {
+			updatePromise = updatePromise.then(async () => {
+				try {
+					// Replace the accumulated text entirely, with truncation
+					const MAX_MAIN_LENGTH = 35000;
+					const truncationNote = "\n\n_(message truncated, ask me to elaborate on specific parts)_";
+					if (text.length > MAX_MAIN_LENGTH) {
+						accumulatedText = text.substring(0, MAX_MAIN_LENGTH - truncationNote.length) + truncationNote;
+					} else {
+						accumulatedText = text;
+					}
+
+					const displayText = isWorking ? accumulatedText + workingIndicator : accumulatedText;
+
+					if (messageTs) {
+						await slack.updateMessage(event.channel, messageTs, displayText);
+					} else {
+						messageTs = await slack.postMessage(event.channel, displayText);
+					}
+				} catch (err) {
+					log.logWarning("Slack replaceMessage error", err instanceof Error ? err.message : String(err));
+				}
+			});
+			await updatePromise;
+		},
+
+		respondInThread: async (text: string) => {
+			updatePromise = updatePromise.then(async () => {
+				try {
+					if (messageTs) {
+						// Truncate thread messages if too long (20K limit for safety)
+						const MAX_THREAD_LENGTH = 20000;
+						let threadText = text;
+						if (threadText.length > MAX_THREAD_LENGTH) {
+							threadText = `${threadText.substring(0, MAX_THREAD_LENGTH - 50)}\n\n_(truncated)_`;
+						}
+
+						const ts = await slack.postInThread(event.channel, messageTs, threadText);
+						threadMessageTs.push(ts);
+					}
+				} catch (err) {
+					log.logWarning("Slack respondInThread error", err instanceof Error ? err.message : String(err));
+				}
+			});
+			await updatePromise;
+		},
+
+		setTyping: async (isTyping: boolean) => {
+			if (isTyping && !messageTs) {
+				updatePromise = updatePromise.then(async () => {
+					try {
+						if (!messageTs) {
+							accumulatedText = eventFilename ? `_Starting event: ${eventFilename}_` : "_Thinking_";
+							messageTs = await slack.postMessage(event.channel, accumulatedText + workingIndicator);
+						}
+					} catch (err) {
+						log.logWarning("Slack setTyping error", err instanceof Error ? err.message : String(err));
+					}
+				});
+				await updatePromise;
+			}
+		},
+
+		uploadFile: async (filePath: string, title?: string) => {
+			await slack.uploadFile(event.channel, filePath, title);
+		},
+
+		setWorking: async (working: boolean) => {
+			updatePromise = updatePromise.then(async () => {
+				try {
+					isWorking = working;
+					if (messageTs) {
+						const displayText = isWorking ? accumulatedText + workingIndicator : accumulatedText;
+						await slack.updateMessage(event.channel, messageTs, displayText);
+					}
+				} catch (err) {
+					log.logWarning("Slack setWorking error", err instanceof Error ? err.message : String(err));
+				}
+			});
+			await updatePromise;
+		},
+
+		deleteMessage: async () => {
+			updatePromise = updatePromise.then(async () => {
+				// Delete thread messages first (in reverse order)
+				for (let i = threadMessageTs.length - 1; i >= 0; i--) {
+					try {
+						await slack.deleteMessage(event.channel, threadMessageTs[i]);
+					} catch {
+						// Ignore errors deleting thread messages
+					}
+				}
+				threadMessageTs.length = 0;
+				// Then delete main message
+				if (messageTs) {
+					await slack.deleteMessage(event.channel, messageTs);
+					messageTs = null;
+				}
+			});
+			await updatePromise;
+		},
+	};
+}
+
+// ============================================================================
+// Handler
+// ============================================================================
+
+const handler: MomHandler = {
+	isRunning(channelId: string): boolean {
+		const state = channelStates.get(channelId);
+		return state?.running ?? false;
+	},
+
+	async handleStop(channelId: string, slack: SlackBot): Promise<void> {
+		const state = channelStates.get(channelId);
+		if (state?.running) {
+			state.stopRequested = true;
+			state.runner.abort();
+			const ts = await slack.postMessage(channelId, "_Stopping..._");
+			state.stopMessageTs = ts; // Save for updating later
+		} else {
+			await slack.postMessage(channelId, "_Nothing running_");
+		}
+	},
+
+	async handleEvent(event: SlackEvent, slack: SlackBot, isEvent?: boolean): Promise<void> {
+		const state = getState(event.channel);
+
+		// Start run
+		state.running = true;
+		state.stopRequested = false;
+
+		log.logInfo(`[${event.channel}] Starting run: ${event.text.substring(0, 50)}`);
+
+		try {
+			// Create context adapter
+			const ctx = createSlackContext(event, slack, state, isEvent);
+
+			// Run the agent
+			await ctx.setTyping(true);
+			await ctx.setWorking(true);
+			const result = await state.runner.run(ctx as any, state.store);
+			await ctx.setWorking(false);
+
+			if (result.stopReason === "aborted" && state.stopRequested) {
+				if (state.stopMessageTs) {
+					await slack.updateMessage(event.channel, state.stopMessageTs, "_Stopped_");
+					state.stopMessageTs = undefined;
+				} else {
+					await slack.postMessage(event.channel, "_Stopped_");
+				}
+			}
+		} catch (err) {
+			log.logWarning(`[${event.channel}] Run error`, err instanceof Error ? err.message : String(err));
+		} finally {
+			state.running = false;
+		}
+	},
+};
+
+// ============================================================================
+// Start
+// ============================================================================
+
+log.logStartup(workingDir, sandbox.type === "host" ? "host" : `docker:${sandbox.container}`);
+
+// Shared store for attachment downloads (also used per-channel in getState)
+const sharedStore = new ChannelStore({ workingDir, botToken: MOM_SLACK_BOT_TOKEN! });
+
+const bot = new SlackBotClass(handler, {
+	appToken: MOM_SLACK_APP_TOKEN,
+	botToken: MOM_SLACK_BOT_TOKEN,
+	workingDir,
+	store: sharedStore,
+});
+
+// Start events watcher
+const eventsWatcher = createEventsWatcher(workingDir, bot);
+eventsWatcher.start();
+
+// Handle shutdown
+process.on("SIGINT", () => {
+	log.logInfo("Shutting down...");
+	eventsWatcher.stop();
+	process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+	log.logInfo("Shutting down...");
+	eventsWatcher.stop();
+	process.exit(0);
+});
+
+bot.start();