@ottocode/server 0.1.173

package/src/routes/session-files.ts

@@ -0,0 +1,387 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@ottocode/sdk';
+import { getDb } from '@ottocode/database';
+import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { eq, and, inArray } from 'drizzle-orm';
+import { serializeError } from '../runtime/errors/api-error.ts';
+import { logger } from '@ottocode/sdk';
+
+const FILE_EDIT_TOOLS = [
+	'Write',
+	'ApplyPatch',
+	'Edit',
+	'write',
+	'apply_patch',
+	'edit',
+];
+
+interface FileOperation {
+	path: string;
+	operation: 'write' | 'patch' | 'edit' | 'create';
+	timestamp: number;
+	toolCallId: string;
+	toolName: string;
+	patch?: string;
+	content?: string;
+	artifact?: {
+		kind: string;
+		patch?: string;
+		summary?: { additions: number; deletions: number };
+	};
+}
+
+interface SessionFile {
+	path: string;
+	operations: FileOperation[];
+	operationCount: number;
+	firstModified: number;
+	lastModified: number;
+}
+
+interface ToolResultData {
+	path?: string;
+	args?: Record<string, unknown>;
+	files?: Array<string | { path: string }>;
+	result?: {
+		ok?: boolean;
+		artifact?: {
+			kind?: string;
+			patch?: string;
+			summary?: { additions?: number; deletions?: number };
+		};
+	};
+	artifact?: {
+		kind?: string;
+		patch?: string;
+		summary?: { additions?: number; deletions?: number };
+	};
+	patch?: string;
+}
+
+function extractFilePathFromToolCall(
+	toolName: string,
+	content: unknown,
+): string | null {
+	if (!content || typeof content !== 'object') return null;
+
+	const c = content as Record<string, unknown>;
+	const args = c.args as Record<string, unknown> | undefined;
+
+	const name = toolName.toLowerCase();
+
+	if (name === 'write' || name === 'edit') {
+		if (args && typeof args.path === 'string') return args.path;
+		if (typeof c.path === 'string') return c.path;
+	}
+
+	if (name === 'applypatch' || name === 'apply_patch') {
+		const patch = args?.patch ?? c.patch;
+		if (typeof patch === 'string') {
+			const matches = [
+				...patch.matchAll(/\*\*\* (?:Update|Add|Delete) File: (.+)/g),
+			];
+			if (matches.length > 0) return matches[0][1].trim();
+			const unifiedMatch = patch.match(/^(?:---|\+\+\+) [ab]\/(.+)$/m);
+			if (unifiedMatch) return unifiedMatch[1].trim();
+		}
+		if (args && typeof args.path === 'string') return args.path;
+		if (typeof c.path === 'string') return c.path;
+	}
+
+	return null;
+}
+
+function extractPatchFromToolCall(
+	toolName: string,
+	content: unknown,
+): string | undefined {
+	if (!content || typeof content !== 'object') return undefined;
+
+	const c = content as Record<string, unknown>;
+	const args = c.args as Record<string, unknown> | undefined;
+	const name = toolName.toLowerCase();
+
+	if (name === 'applypatch' || name === 'apply_patch') {
+		const patch = args?.patch ?? c.patch;
+		if (typeof patch === 'string') return patch;
+	}
+
+	return undefined;
+}
+
+function extractContentFromToolCall(
+	toolName: string,
+	content: unknown,
+): string | undefined {
+	if (!content || typeof content !== 'object') return undefined;
+
+	const c = content as Record<string, unknown>;
+	const args = c.args as Record<string, unknown> | undefined;
+	const name = toolName.toLowerCase();
+
+	if (name === 'write') {
+		const writeContent = args?.content ?? c.content;
+		if (typeof writeContent === 'string') return writeContent;
+	}
+
+	return undefined;
+}
+
+function extractFilesFromToolResult(
+	toolName: string,
+	content: unknown,
+): string[] {
+	if (!content || typeof content !== 'object') return [];
+
+	const c = content as ToolResultData;
+	const files: string[] = [];
+
+	if (typeof c.path === 'string') {
+		files.push(c.path);
+	}
+
+	const args = c.args;
+	if (args && typeof args.path === 'string' && !files.includes(args.path)) {
+		files.push(args.path);
+	}
+
+	if (Array.isArray(c.files)) {
+		for (const f of c.files) {
+			if (typeof f === 'string' && !files.includes(f)) files.push(f);
+			if (f && typeof f === 'object' && typeof f.path === 'string') {
+				if (!files.includes(f.path)) files.push(f.path);
+			}
+		}
+	}
+
+	const name = toolName.toLowerCase();
+	if (name === 'applypatch' || name === 'apply_patch') {
+		const patch =
+			c.patch ??
+			(args?.patch as string | undefined) ??
+			c.result?.artifact?.patch;
+		if (typeof patch === 'string') {
+			const matches = patch.matchAll(
+				/\*\*\* (?:Update|Add|Delete) File: (.+)/g,
+			);
+			for (const match of matches) {
+				const fp = match[1].trim();
+				if (!files.includes(fp)) files.push(fp);
+			}
+		}
+	}
+
+	return files;
+}
+
+function extractDataFromToolResult(
+	toolName: string,
+	content: unknown,
+): {
+	patch?: string;
+	writeContent?: string;
+	artifact?: FileOperation['artifact'];
+} {
+	if (!content || typeof content !== 'object') return {};
+
+	const c = content as ToolResultData;
+	const args = c.args as Record<string, unknown> | undefined;
+	const name = toolName.toLowerCase();
+
+	let patch: string | undefined;
+	let writeContent: string | undefined;
+	let artifact: FileOperation['artifact'] | undefined;
+
+	if (name === 'applypatch' || name === 'apply_patch') {
+		patch = (args?.patch as string | undefined) ?? c.patch;
+	}
+
+	if (name === 'write') {
+		writeContent = args?.content as string | undefined;
+	}
+
+	const rawArtifact = c.result?.artifact ?? c.artifact;
+	if (rawArtifact && typeof rawArtifact === 'object') {
+		artifact = {
+			kind: rawArtifact.kind || 'unknown',
+			patch: rawArtifact.patch,
+			summary: rawArtifact.summary
+				? {
+						additions: rawArtifact.summary.additions || 0,
+						deletions: rawArtifact.summary.deletions || 0,
+					}
+				: undefined,
+		};
+	}
+
+	return { patch, writeContent, artifact };
+}
+
+function getOperationType(
+	toolName: string,
+): 'write' | 'patch' | 'edit' | 'create' {
+	const name = toolName.toLowerCase();
+	if (name === 'write') return 'write';
+	if (name === 'applypatch' || name === 'apply_patch') return 'patch';
+	if (name === 'edit') return 'edit';
+	return 'write';
+}
+
+export function registerSessionFilesRoutes(app: Hono) {
+	app.get('/v1/sessions/:sessionId/files', async (c) => {
+		try {
+			const sessionId = c.req.param('sessionId');
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+
+			const sessionRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId))
+				.limit(1);
+
+			if (!sessionRows.length) {
+				return c.json({ error: 'Session not found' }, 404);
+			}
+
+			const messageRows = await db
+				.select({ id: messages.id })
+				.from(messages)
+				.where(eq(messages.sessionId, sessionId));
+
+			const messageIds = messageRows.map((m) => m.id);
+
+			if (!messageIds.length) {
+				return c.json({
+					files: [],
+					totalFiles: 0,
+					totalOperations: 0,
+				});
+			}
+
+			const parts = await db
+				.select()
+				.from(messageParts)
+				.where(
+					and(
+						inArray(messageParts.messageId, messageIds),
+						inArray(messageParts.toolName, FILE_EDIT_TOOLS),
+					),
+				);
+
+			const fileOperationsMap = new Map<string, FileOperation[]>();
+			const toolCallDataMap = new Map<
+				string,
+				{ patch?: string; content?: string }
+			>();
+
+			for (const part of parts) {
+				if (!part.toolName) continue;
+
+				let content: unknown;
+				try {
+					content = JSON.parse(part.content);
+				} catch {
+					continue;
+				}
+
+				if (part.type === 'tool_call') {
+					const callId = part.toolCallId || part.id;
+					const patch = extractPatchFromToolCall(part.toolName, content);
+					const writeContent = extractContentFromToolCall(
+						part.toolName,
+						content,
+					);
+
+					toolCallDataMap.set(callId, { patch, content: writeContent });
+
+					const path = extractFilePathFromToolCall(part.toolName, content);
+					if (path) {
+						const operation: FileOperation = {
+							path,
+							operation: getOperationType(part.toolName),
+							timestamp: part.startedAt || Date.now(),
+							toolCallId: callId,
+							toolName: part.toolName,
+							patch,
+							content: writeContent,
+						};
+
+						const existing = fileOperationsMap.get(path) || [];
+						const isDuplicate = existing.some(
+							(op) => op.toolCallId === operation.toolCallId,
+						);
+						if (!isDuplicate) {
+							existing.push(operation);
+							fileOperationsMap.set(path, existing);
+						}
+					}
+				} else if (part.type === 'tool_result') {
+					const filePaths = extractFilesFromToolResult(part.toolName, content);
+					const { patch, writeContent, artifact } = extractDataFromToolResult(
+						part.toolName,
+						content,
+					);
+					const callId = part.toolCallId || part.id;
+					const callData = toolCallDataMap.get(callId);
+
+					for (const filePath of filePaths) {
+						if (!filePath) continue;
+
+						const existing = fileOperationsMap.get(filePath) || [];
+						const existingOp = existing.find((op) => op.toolCallId === callId);
+
+						if (existingOp) {
+							existingOp.artifact = artifact;
+							existingOp.timestamp = part.completedAt || existingOp.timestamp;
+							if (!existingOp.patch && patch) {
+								existingOp.patch = patch;
+							}
+							if (!existingOp.content && writeContent) {
+								existingOp.content = writeContent;
+							}
+						} else {
+							const operation: FileOperation = {
+								path: filePath,
+								operation: getOperationType(part.toolName),
+								timestamp: part.completedAt || part.startedAt || Date.now(),
+								toolCallId: callId,
+								toolName: part.toolName,
+								patch: callData?.patch ?? patch,
+								content: callData?.content ?? writeContent,
+								artifact,
+							};
+							existing.push(operation);
+							fileOperationsMap.set(filePath, existing);
+						}
+					}
+				}
+			}
+
+			const files: SessionFile[] = [];
+			for (const [path, operations] of fileOperationsMap) {
+				operations.sort((a, b) => a.timestamp - b.timestamp);
+				files.push({
+					path,
+					operations,
+					operationCount: operations.length,
+					firstModified: operations[0]?.timestamp || 0,
+					lastModified: operations[operations.length - 1]?.timestamp || 0,
+				});
+			}
+
+			files.sort((a, b) => b.lastModified - a.lastModified);
+
+			return c.json({
+				files,
+				totalFiles: files.length,
+				totalOperations: parts.length,
+			});
+		} catch (error) {
+			logger.error('Failed to get session files', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/session-messages.ts

@@ -0,0 +1,170 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@ottocode/sdk';
+import { getDb } from '@ottocode/database';
+import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { eq, inArray } from 'drizzle-orm';
+import {
+	validateProviderModel,
+	isProviderAuthorized,
+	ensureProviderEnv,
+} from '@ottocode/sdk';
+import { dispatchAssistantMessage } from '../runtime/message/service.ts';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../runtime/errors/api-error.ts';
+
+type MessagePartRow = typeof messageParts.$inferSelect;
+type SessionRow = typeof sessions.$inferSelect;
+
+export function registerSessionMessagesRoutes(app: Hono) {
+	// List messages for a session
+	app.get('/v1/sessions/:id/messages', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+			const id = c.req.param('id');
+			const rows = await db
+				.select()
+				.from(messages)
+				.where(eq(messages.sessionId, id))
+				.orderBy(messages.createdAt);
+			const without = c.req.query('without');
+			if (without !== 'parts') {
+				const ids = rows.map((m) => m.id);
+				const parts = ids.length
+					? await db
+							.select()
+							.from(messageParts)
+							.where(inArray(messageParts.messageId, ids))
+					: [];
+				const partsByMsg = new Map<string, MessagePartRow[]>();
+				for (const p of parts) {
+					const existing = partsByMsg.get(p.messageId);
+					if (existing) existing.push(p);
+					else partsByMsg.set(p.messageId, [p]);
+				}
+				const wantParsed = (() => {
+					const q = (c.req.query('parsed') || '').toLowerCase();
+					return q === '1' || q === 'true' || q === 'yes';
+				})();
+				function parseContent(raw: string): Record<string, unknown> | string {
+					try {
+						const v = JSON.parse(String(raw ?? ''));
+						if (v && typeof v === 'object' && !Array.isArray(v))
+							return v as Record<string, unknown>;
+					} catch {}
+					return raw;
+				}
+				const enriched = rows.map((m) => {
+					const parts = (partsByMsg.get(m.id) ?? []).sort(
+						(a, b) => a.index - b.index,
+					);
+					const mapped = parts.map((p) => {
+						const parsed = parseContent(p.content);
+						return wantParsed
+							? { ...p, content: parsed }
+							: { ...p, contentJson: parsed };
+					});
+					return { ...m, parts: mapped };
+				});
+				return c.json(enriched);
+			}
+			return c.json(rows);
+		} catch (error) {
+			logger.error('Failed to list session messages', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	// Post a user message and get assistant reply (non-streaming for v0)
+	app.post('/v1/sessions/:id/messages', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+			const sessionId = c.req.param('id');
+			const body = await c.req.json().catch(() => ({}));
+
+			// DEBUG: Log received body
+			logger.info('[API] Received message request', {
+				sessionId,
+				hasContent: !!body?.content,
+				hasUserContext: !!body?.userContext,
+				userContext: body?.userContext
+					? `${String(body.userContext).substring(0, 50)}...`
+					: 'NONE',
+			});
+
+			// Load session to inherit its provider/model/agent by default
+			const sessionRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId));
+			if (!sessionRows.length) {
+				logger.warn('Session not found', { sessionId });
+				return c.json({ error: 'Session not found' }, 404);
+			}
+			const sess: SessionRow = sessionRows[0];
+			const provider = body?.provider ?? sess.provider ?? cfg.defaults.provider;
+			const modelName = body?.model ?? sess.model ?? cfg.defaults.model;
+			const agent = body?.agent ?? sess.agent ?? cfg.defaults.agent;
+			const content = body?.content ?? '';
+			const userContext = body?.userContext;
+			const images = Array.isArray(body?.images) ? body.images : undefined;
+			const files = Array.isArray(body?.files) ? body.files : undefined;
+
+			// DEBUG: Log extracted userContext
+			logger.info('[API] Extracted userContext', {
+				userContext: userContext
+					? `${String(userContext).substring(0, 50)}...`
+					: 'NONE',
+				typeOf: typeof userContext,
+			});
+
+			const reasoning = body?.reasoningText === true;
+
+			// Validate model capabilities if tools are allowed for this agent
+			const wantsToolCalls = true; // agent toolset may be non-empty
+			try {
+				validateProviderModel(provider, modelName, { wantsToolCalls });
+			} catch (err) {
+				logger.error('Model validation failed', err, { provider, modelName });
+				const message = err instanceof Error ? err.message : String(err);
+				return c.json({ error: message }, 400);
+			}
+			// Enforce provider auth: only allow providers/models the user authenticated for
+			const authorized = await isProviderAuthorized(cfg, provider);
+			if (!authorized) {
+				logger.warn('Provider not authorized', { provider });
+				return c.json(
+					{
+						error: `Provider ${provider} is not configured. Run \`otto auth login\` to add credentials.`,
+					},
+					400,
+				);
+			}
+			await ensureProviderEnv(cfg, provider);
+
+			const { assistantMessageId } = await dispatchAssistantMessage({
+				cfg,
+				db,
+				session: sess,
+				agent,
+				provider,
+				model: modelName,
+				content,
+				oneShot: Boolean(body?.oneShot),
+				userContext,
+				reasoningText: reasoning,
+				images,
+				files,
+			});
+			return c.json({ messageId: assistantMessageId }, 202);
+		} catch (error) {
+			logger.error('Failed to create session message', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/session-stream.ts

@@ -0,0 +1,61 @@
+import type { Hono } from 'hono';
+import { subscribe } from '../events/bus.ts';
+import type { OttoEvent } from '../events/types.ts';
+
+function safeStringify(obj: unknown): string {
+	return JSON.stringify(obj, (_key, value) =>
+		typeof value === 'bigint' ? Number(value) : value,
+	);
+}
+
+export function registerSessionStreamRoute(app: Hono) {
+	app.get('/v1/sessions/:id/stream', async (c) => {
+		const sessionId = c.req.param('id');
+		const headers = new Headers({
+			'Content-Type': 'text/event-stream',
+			'Cache-Control': 'no-cache, no-transform',
+			Connection: 'keep-alive',
+		});
+
+		const encoder = new TextEncoder();
+
+		const stream = new ReadableStream<Uint8Array>({
+			start(controller) {
+				const write = (evt: OttoEvent) => {
+					let line: string;
+					try {
+						line =
+							`event: ${evt.type}\n` +
+							`data: ${safeStringify(evt.payload ?? {})}\n\n`;
+					} catch {
+						line = `event: ${evt.type}\ndata: {}\n\n`;
+					}
+					controller.enqueue(encoder.encode(line));
+				};
+				const unsubscribe = subscribe(sessionId, write);
+				// Initial ping
+				controller.enqueue(encoder.encode(`: connected ${sessionId}\n\n`));
+				// Heartbeat every 5s to prevent idle timeout (Bun default is 10s)
+				const hb = setInterval(() => {
+					try {
+						controller.enqueue(encoder.encode(`: hb ${Date.now()}\n\n`));
+					} catch {
+						// Controller might be closed
+						clearInterval(hb);
+					}
+				}, 5000);
+
+				const signal = c.req.raw?.signal as AbortSignal | undefined;
+				signal?.addEventListener('abort', () => {
+					clearInterval(hb);
+					unsubscribe();
+					try {
+						controller.close();
+					} catch {}
+				});
+			},
+		});
+
+		return new Response(stream, { headers });
+	});
+}