@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/apps/pi-extension/server/annotations.ts

@@ -0,0 +1,85 @@
+/**
+ * Editor annotation handler (in-memory store for VS Code integration).
+ * EditorAnnotation type, createEditorAnnotationHandler
+ */
+
+import { randomUUID } from "node:crypto";
+import type { IncomingMessage } from "node:http";
+import { json, parseBody } from "./helpers";
+
+interface EditorAnnotation {
+	id: string;
+	filePath: string;
+	selectedText: string;
+	lineStart: number;
+	lineEnd: number;
+	comment?: string;
+	createdAt: number;
+}
+
+export function createEditorAnnotationHandler() {
+	const annotations: EditorAnnotation[] = [];
+
+	return {
+		async handle(
+			req: IncomingMessage,
+			res: import("node:http").ServerResponse,
+			url: URL,
+		): Promise<boolean> {
+			if (url.pathname === "/api/editor-annotations" && req.method === "GET") {
+				json(res, { annotations });
+				return true;
+			}
+
+			if (url.pathname === "/api/editor-annotation" && req.method === "POST") {
+				try {
+					const body = await parseBody(req);
+					if (
+						!body.filePath ||
+						!body.selectedText ||
+						!body.lineStart ||
+						!body.lineEnd
+					) {
+						json(res, { error: "Missing required fields" }, 400);
+						return true;
+					}
+
+					const annotation: EditorAnnotation = {
+						id: randomUUID(),
+						filePath: String(body.filePath),
+						selectedText: String(body.selectedText),
+						lineStart: Number(body.lineStart),
+						lineEnd: Number(body.lineEnd),
+						comment: typeof body.comment === "string" ? body.comment : undefined,
+						createdAt: Date.now(),
+					};
+
+					annotations.push(annotation);
+					json(res, { id: annotation.id });
+				} catch {
+					json(res, { error: "Invalid JSON" }, 400);
+				}
+				return true;
+			}
+
+			if (
+				url.pathname === "/api/editor-annotation" &&
+				req.method === "DELETE"
+			) {
+				const id = url.searchParams.get("id");
+				if (!id) {
+					json(res, { error: "Missing id parameter" }, 400);
+					return true;
+				}
+				const idx = annotations.findIndex((annotation) => annotation.id === id);
+				if (idx !== -1) {
+					annotations.splice(idx, 1);
+				}
+				json(res, { ok: true });
+				return true;
+			}
+
+			return false;
+		},
+	};
+}

package/3p/pi-plannotator/apps/pi-extension/server/external-annotations.ts

@@ -0,0 +1,189 @@
+/**
+ * External Annotations — Pi (node:http) server handler.
+ *
+ * Thin HTTP adapter over the shared annotation store. Mirrors the Bun
+ * handler at packages/server/external-annotations.ts but uses node:http
+ * IncomingMessage/ServerResponse + res.write() for SSE.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import {
+	createAnnotationStore,
+	transformPlanInput,
+	transformReviewInput,
+	serializeSSEEvent,
+	HEARTBEAT_COMMENT,
+	HEARTBEAT_INTERVAL_MS,
+	type StorableAnnotation,
+	type ExternalAnnotationEvent,
+} from "../generated/external-annotation.js";
+import { json, parseBody } from "./helpers.js";
+
+// ---------------------------------------------------------------------------
+// Route prefix
+// ---------------------------------------------------------------------------
+
+const BASE = "/api/external-annotations";
+const STREAM = `${BASE}/stream`;
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export function createExternalAnnotationHandler(mode: "plan" | "review") {
+	const store = createAnnotationStore<StorableAnnotation>();
+	const subscribers = new Set<ServerResponse>();
+	const transform = mode === "plan" ? transformPlanInput : transformReviewInput;
+
+	// Wire store mutations → SSE broadcast
+	store.onMutation((event: ExternalAnnotationEvent<StorableAnnotation>) => {
+		const data = serializeSSEEvent(event);
+		for (const res of subscribers) {
+			try {
+				res.write(data);
+			} catch {
+				// Response closed — clean up
+				subscribers.delete(res);
+			}
+		}
+	});
+
+	return {
+		/** Push annotations directly into the store (bypasses HTTP, reuses same validation). */
+		addAnnotations(body: unknown): { ids: string[] } | { error: string } {
+			const parsed = transform(body);
+			if ("error" in parsed) return { error: parsed.error };
+			const created = store.add(parsed.annotations);
+			return { ids: created.map((a: { id: string }) => a.id) };
+		},
+
+		async handle(
+			req: IncomingMessage,
+			res: ServerResponse,
+			url: URL,
+		): Promise<boolean> {
+			// --- SSE stream ---
+			if (url.pathname === STREAM && req.method === "GET") {
+				res.writeHead(200, {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-cache",
+					Connection: "keep-alive",
+				});
+
+				// Disable idle timeout for SSE connections
+				res.setTimeout(0);
+
+				// Send current state as snapshot
+				const snapshot: ExternalAnnotationEvent<StorableAnnotation> = {
+					type: "snapshot",
+					annotations: store.getAll(),
+				};
+				res.write(serializeSSEEvent(snapshot));
+
+				subscribers.add(res);
+
+				// Heartbeat to keep connection alive
+				const heartbeatTimer = setInterval(() => {
+					try {
+						res.write(HEARTBEAT_COMMENT);
+					} catch {
+						clearInterval(heartbeatTimer);
+						subscribers.delete(res);
+					}
+				}, HEARTBEAT_INTERVAL_MS);
+
+				// Clean up on disconnect
+				res.on("close", () => {
+					clearInterval(heartbeatTimer);
+					subscribers.delete(res);
+				});
+
+				// Don't end the response — SSE stays open
+				return true;
+			}
+
+			// --- GET snapshot (polling fallback) ---
+			if (url.pathname === BASE && req.method === "GET") {
+				const since = url.searchParams.get("since");
+				if (since !== null) {
+					const sinceVersion = parseInt(since, 10);
+					if (!isNaN(sinceVersion) && sinceVersion === store.version) {
+						res.writeHead(304);
+						res.end();
+						return true;
+					}
+				}
+				json(res, {
+					annotations: store.getAll(),
+					version: store.version,
+				});
+				return true;
+			}
+
+			// --- POST (add single or batch) ---
+			if (url.pathname === BASE && req.method === "POST") {
+				try {
+					const body = await parseBody(req);
+					const parsed = transform(body);
+
+					if ("error" in parsed) {
+						json(res, { error: parsed.error }, 400);
+						return true;
+					}
+
+					const created = store.add(parsed.annotations);
+					json(res, { ids: created.map((a: StorableAnnotation) => a.id) }, 201);
+				} catch {
+					json(res, { error: "Invalid JSON" }, 400);
+				}
+				return true;
+			}
+
+			// --- PATCH (update fields on a single annotation) ---
+			if (url.pathname === BASE && req.method === "PATCH") {
+				const id = url.searchParams.get("id");
+				if (!id) {
+					json(res, { error: "Missing ?id parameter" }, 400);
+					return true;
+				}
+				try {
+					const body = await parseBody(req);
+					const updated = store.update(id, body as Partial<StorableAnnotation>);
+					if (!updated) {
+						json(res, { error: "Not found" }, 404);
+						return true;
+					}
+					json(res, { annotation: updated });
+				} catch {
+					json(res, { error: "Invalid JSON" }, 400);
+				}
+				return true;
+			}
+
+			// --- DELETE (by id, by source, or clear all) ---
+			if (url.pathname === BASE && req.method === "DELETE") {
+				const id = url.searchParams.get("id");
+				const source = url.searchParams.get("source");
+
+				if (id) {
+					store.remove(id);
+					json(res, { ok: true });
+					return true;
+				}
+
+				if (source) {
+					const count = store.clearBySource(source);
+					json(res, { ok: true, removed: count });
+					return true;
+				}
+
+				const count = store.clearAll();
+				json(res, { ok: true, removed: count });
+				return true;
+			}
+
+			// Not handled — pass through
+			return false;
+		},
+	};
+}

package/3p/pi-plannotator/apps/pi-extension/server/handlers.ts

@@ -0,0 +1,210 @@
+/**
+ * Shared request handlers reused across plan, review, and annotate servers.
+ * handleImageRequest, handleUploadRequest, handleDraftRequest, handleFavicon
+ */
+
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import type { IncomingMessage } from "node:http";
+import { tmpdir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
+import { saveDraft, loadDraft, deleteDraft } from "../generated/draft.js";
+import { FAVICON_SVG } from "../generated/favicon.js";
+
+import { json, parseBody, send, toWebRequest } from "./helpers";
+
+type Res = import("node:http").ServerResponse;
+
+const ALLOWED_IMAGE_EXTENSIONS = new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"svg",
+	"bmp",
+	"ico",
+	"tiff",
+	"tif",
+	"avif",
+]);
+
+const IMAGE_CONTENT_TYPES: Record<string, string> = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	bmp: "image/bmp",
+	ico: "image/x-icon",
+	tiff: "image/tiff",
+	tif: "image/tiff",
+	avif: "image/avif",
+};
+
+const UPLOAD_DIR = join(tmpdir(), "plannotator");
+
+function getExtension(filePath: string): string {
+	const lastDot = filePath.lastIndexOf(".");
+	if (lastDot === -1) return "";
+	return filePath.slice(lastDot + 1).toLowerCase();
+}
+
+function validateImagePath(rawPath: string): {
+	valid: boolean;
+	resolved: string;
+	error?: string;
+} {
+	const resolved = resolvePath(rawPath);
+	const ext = getExtension(resolved);
+
+	if (!ALLOWED_IMAGE_EXTENSIONS.has(ext)) {
+		return {
+			valid: false,
+			resolved,
+			error: "Path does not point to a supported image file",
+		};
+	}
+
+	return { valid: true, resolved };
+}
+
+function validateUploadExtension(fileName: string): {
+	valid: boolean;
+	ext: string;
+	error?: string;
+} {
+	const ext = getExtension(fileName) || "png";
+	if (!ALLOWED_IMAGE_EXTENSIONS.has(ext)) {
+		return {
+			valid: false,
+			ext,
+			error: `File extension ".${ext}" is not a supported image type`,
+		};
+	}
+
+	return { valid: true, ext };
+}
+
+function getImageContentType(filePath: string): string {
+	return (
+		IMAGE_CONTENT_TYPES[getExtension(filePath)] || "application/octet-stream"
+	);
+}
+
+export function handleImageRequest(res: Res, url: URL): void {
+	const imagePath = url.searchParams.get("path");
+	if (!imagePath) {
+		send(res, "Missing path parameter", 400, { "Content-Type": "text/plain" });
+		return;
+	}
+
+	const tryServePath = (candidate: string): boolean => {
+		const validation = validateImagePath(candidate);
+		if (!validation.valid) return false;
+		try {
+			if (!existsSync(validation.resolved)) return false;
+			const data = readFileSync(validation.resolved);
+			send(res, data, 200, {
+				"Content-Type": getImageContentType(validation.resolved),
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	};
+
+	if (tryServePath(imagePath)) return;
+
+	const base = url.searchParams.get("base");
+	if (
+		base &&
+		!imagePath.startsWith("/") &&
+		tryServePath(resolvePath(base, imagePath))
+	) {
+		return;
+	}
+
+	const validation = validateImagePath(imagePath);
+	if (!validation.valid) {
+		send(res, validation.error || "Invalid image path", 403, {
+			"Content-Type": "text/plain",
+		});
+		return;
+	}
+
+	send(res, "File not found", 404, { "Content-Type": "text/plain" });
+}
+
+export async function handleUploadRequest(
+	req: IncomingMessage,
+	res: Res,
+): Promise<void> {
+	try {
+		const request = toWebRequest(req);
+		const formData = await request.formData();
+		const file = formData.get("file");
+		if (
+			!file ||
+			typeof file !== "object" ||
+			!("arrayBuffer" in file) ||
+			!("name" in file)
+		) {
+			json(res, { error: "No file provided" }, 400);
+			return;
+		}
+
+		const upload = file as File;
+		const extResult = validateUploadExtension(upload.name);
+		if (!extResult.valid) {
+			json(res, { error: extResult.error }, 400);
+			return;
+		}
+
+		mkdirSync(UPLOAD_DIR, { recursive: true });
+		const tempPath = join(UPLOAD_DIR, `${randomUUID()}.${extResult.ext}`);
+		const bytes = Buffer.from(await upload.arrayBuffer());
+		writeFileSync(tempPath, bytes);
+		json(res, { path: tempPath, originalName: upload.name });
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Upload failed";
+		json(res, { error: message }, 500);
+	}
+}
+
+export function handleDraftRequest(
+	req: IncomingMessage,
+	res: Res,
+	draftKey: string,
+): Promise<void> | void {
+	if (req.method === "POST") {
+		return parseBody(req)
+			.then((body) => {
+				saveDraft(draftKey, body);
+				json(res, { ok: true });
+			})
+			.catch((err: unknown) => {
+				const message = err instanceof Error ? err.message : "Failed to save draft";
+				console.error(`[draft] save failed: ${message}`);
+				json(res, { error: message }, 500);
+			});
+	} else if (req.method === "DELETE") {
+		deleteDraft(draftKey);
+		json(res, { ok: true });
+	} else {
+		const draft = loadDraft(draftKey);
+		if (!draft) {
+			json(res, { found: false }, 404);
+			return;
+		}
+		json(res, draft);
+	}
+}
+
+export function handleFavicon(res: Res): void {
+	send(res, FAVICON_SVG, 200, {
+		"Content-Type": "image/svg+xml",
+		"Cache-Control": "public, max-age=86400",
+	});
+}

package/3p/pi-plannotator/apps/pi-extension/server/helpers.ts

@@ -0,0 +1,78 @@
+/**
+ * Core HTTP helpers for Pi extension servers.
+ * parseBody, json, html, send, toWebRequest
+ */
+
+import type { IncomingMessage } from "node:http";
+import { Readable } from "node:stream";
+
+export function parseBody(
+	req: IncomingMessage,
+): Promise<Record<string, unknown>> {
+	return new Promise((resolve) => {
+		let data = "";
+		req.on("data", (chunk: string) => (data += chunk));
+		req.on("end", () => {
+			try {
+				resolve(JSON.parse(data));
+			} catch {
+				resolve({});
+			}
+		});
+	});
+}
+
+export function json(
+	res: import("node:http").ServerResponse,
+	data: unknown,
+	status = 200,
+): void {
+	res.writeHead(status, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(data));
+}
+
+export function html(
+	res: import("node:http").ServerResponse,
+	content: string,
+): void {
+	res.writeHead(200, { "Content-Type": "text/html" });
+	res.end(content);
+}
+
+export function send(
+	res: import("node:http").ServerResponse,
+	body: string | Buffer,
+	status = 200,
+	headers: Record<string, string> = {},
+): void {
+	res.writeHead(status, headers);
+	res.end(body);
+}
+
+export function requestUrl(req: IncomingMessage): URL {
+	return new URL(req.url ?? "/", "http://localhost");
+}
+
+export function toWebRequest(req: IncomingMessage): Request {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value === undefined) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) headers.append(key, item);
+		} else {
+			headers.set(key, value);
+		}
+	}
+
+	const init: RequestInit & { duplex?: "half" } = {
+		method: req.method,
+		headers,
+	};
+
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		init.body = Readable.toWeb(req) as unknown as BodyInit;
+		init.duplex = "half";
+	}
+
+	return new Request(`http://localhost${req.url ?? "/"}`, init);
+}

package/3p/pi-plannotator/apps/pi-extension/server/ide.ts

@@ -0,0 +1,46 @@
+/**
+ * IDE integration — open plan diffs in VS Code.
+ * Node.js equivalent of packages/server/ide.ts.
+ */
+
+import { spawn } from "node:child_process";
+
+/** Open two files in VS Code's diff viewer. Node.js equivalent of packages/server/ide.ts */
+export function openEditorDiff(
+	oldPath: string,
+	newPath: string,
+): Promise<{ ok: true } | { error: string }> {
+	return new Promise((resolve) => {
+		const proc = spawn("code", ["--diff", oldPath, newPath], {
+			stdio: ["ignore", "ignore", "pipe"],
+		});
+		let stderr = "";
+		proc.stderr?.on("data", (chunk: Buffer) => {
+			stderr += chunk.toString();
+		});
+		proc.on("error", (err) => {
+			if (err.message.includes("ENOENT")) {
+				resolve({
+					error:
+						"VS Code CLI not found. Run 'Shell Command: Install code command in PATH' from the VS Code command palette.",
+				});
+			} else {
+				resolve({ error: err.message });
+			}
+		});
+		proc.on("close", (code) => {
+			if (code !== 0) {
+				if (stderr.includes("not found") || stderr.includes("ENOENT")) {
+					resolve({
+						error:
+							"VS Code CLI not found. Run 'Shell Command: Install code command in PATH' from the VS Code command palette.",
+					});
+				} else {
+					resolve({ error: `code --diff exited with ${code}: ${stderr}` });
+				}
+			} else {
+				resolve({ ok: true });
+			}
+		});
+	});
+}