agent-canvas 0.1.4 → 0.1.7

package/daemon/src/handlers/api.ts

@@ -0,0 +1,150 @@
+import { readFileSync } from "fs";
+import type { SessionManager } from "../session";
+import { compilePlan } from "../compiler";
+import { watchSession } from "../watcher";
+import { jsonResponse } from "./utils";
+import type { Route } from "../router";
+
+export interface ApiContext {
+  sessionManager: SessionManager;
+  broadcastPlanUpdate: (id: string) => void;
+  port: number;
+}
+
+function readRevisionJsx(sessionManager: SessionManager, sessionId: string, rev: number): string | null {
+  try {
+    const path = sessionManager.getRevisionJsxPath(sessionId, rev);
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export function createApiHandlers(ctx: ApiContext): Route[] {
+  const { sessionManager, broadcastPlanUpdate, port } = ctx;
+
+  async function handlePlanPost(req: Request, _url: URL, match: URLPatternResult): Promise<Response> {
+    const sessionId = match.pathname.groups.id!;
+    try {
+      const body = await req.json();
+      const { jsx, projectRoot, label, sourceFile } = body;
+      if (!jsx) return jsonResponse({ error: "Missing jsx" }, 400);
+
+      const unconsumed = sessionManager.getLatestUnconsumedFeedback(sessionId);
+      if (unconsumed) {
+        sessionManager.consumeFeedback(sessionId, unconsumed.revision);
+        return jsonResponse({
+          ok: false,
+          error: `Unconsumed feedback from revision ${unconsumed.revision}. Address the feedback before pushing a new canvas.`,
+          unconsumedFeedback: unconsumed.feedback,
+          unconsumedRevision: unconsumed.revision,
+        }, 409);
+      }
+
+      const isNew = !sessionManager.get(sessionId);
+      const session = sessionManager.upsert(sessionId, jsx, projectRoot || process.cwd(), label, sourceFile);
+
+      const result = await compilePlan(jsx, session.projectRoot);
+      if (result.ok) {
+        sessionManager.saveCompiled(sessionId, result.js, session.currentRevision);
+        broadcastPlanUpdate(sessionId);
+      }
+
+      watchSession(sessionId, sessionManager, broadcastPlanUpdate);
+
+      const browserUrl = `http://localhost:${port}/s/${sessionId}`;
+      return jsonResponse({
+        ok: result.ok,
+        browserUrl,
+        isNew,
+        revision: session.currentRevision,
+        error: result.ok ? undefined : result.error,
+      });
+    } catch (e: any) {
+      return jsonResponse({ error: e.message }, 500);
+    }
+  }
+
+  async function handlePlanJs(_req: Request, url: URL, match: URLPatternResult): Promise<Response> {
+    const sessionId = match.pathname.groups.id!;
+    const revParam = url.searchParams.get("rev");
+    const rev = revParam ? parseInt(revParam, 10) : undefined;
+
+    let compiled = sessionManager.getCompiled(sessionId, rev);
+
+    if (!compiled && rev) {
+      const session = sessionManager.get(sessionId);
+      if (session) {
+        const jsx = readRevisionJsx(sessionManager, sessionId, rev);
+        if (jsx) {
+          const result = await compilePlan(jsx, session.projectRoot);
+          if (result.ok) {
+            sessionManager.saveCompiled(sessionId, result.js, rev);
+            compiled = result.js;
+          }
+        }
+      }
+    }
+
+    if (!compiled) return jsonResponse({ error: "No compiled plan" }, 404);
+    return new Response(compiled, {
+      headers: {
+        "Content-Type": "application/javascript",
+        "Cache-Control": "no-cache",
+      },
+    });
+  }
+
+  function handleHealth(): Response {
+    const sessions = sessionManager.list().map((s) => s.id);
+    return jsonResponse({ ok: true, sessions });
+  }
+
+  function handleMeta(_req: Request, _url: URL, match: URLPatternResult): Response {
+    const sessionId = match.pathname.groups.id!;
+    const session = sessionManager.get(sessionId);
+    if (!session) return jsonResponse({ error: "Session not found" }, 404);
+    return jsonResponse({
+      projectRoot: session.projectRoot,
+      currentRevision: session.currentRevision,
+      revisions: session.revisions,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+    });
+  }
+
+  function handleSessions(): Response {
+    return jsonResponse(sessionManager.list().map((s) => ({
+      id: s.id,
+      projectRoot: s.projectRoot,
+      currentRevision: s.currentRevision,
+      updatedAt: s.updatedAt,
+    })));
+  }
+
+  function handleFeedbackGet(_req: Request, _url: URL, match: URLPatternResult): Response {
+    const sessionId = match.pathname.groups.id!;
+    const rev = parseInt(match.pathname.groups.rev!, 10);
+    const feedback = sessionManager.getFeedback(sessionId, rev);
+    if (feedback === null) return jsonResponse({ error: "No feedback" }, 404);
+    return jsonResponse({ feedback });
+  }
+
+  function handleFeedbackConsume(_req: Request, _url: URL, match: URLPatternResult): Response {
+    const sessionId = match.pathname.groups.id!;
+    const result = sessionManager.getLatestUnconsumedFeedback(sessionId);
+    if (!result) return jsonResponse({ found: false });
+    sessionManager.consumeFeedback(sessionId, result.revision);
+    return jsonResponse({ found: true, revision: result.revision, feedback: result.feedback });
+  }
+
+  return [
+    { method: "GET", pattern: new URLPattern({ pathname: "/health" }), handler: handleHealth },
+    { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/plan" }), handler: handlePlanPost },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/plan.js" }), handler: handlePlanJs },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/meta" }), handler: handleMeta },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/session/:id/revision/:rev/feedback" }), handler: handleFeedbackGet },
+    { method: "POST", pattern: new URLPattern({ pathname: "/api/session/:id/feedback/consume" }), handler: handleFeedbackConsume },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/sessions" }), handler: handleSessions },
+  ];
+}

package/daemon/src/handlers/files.ts

@@ -0,0 +1,114 @@
+import { join, resolve } from "path";
+import { readdir } from "fs/promises";
+import type { SessionManager } from "../session";
+import { LANG_MAP } from "../../langMap";
+import { jsonResponse } from "./utils";
+import type { Route } from "../router";
+
+const IMAGE_MIME: Record<string, string> = {
+  png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg",
+  gif: "image/gif", svg: "image/svg+xml", webp: "image/webp",
+  ico: "image/x-icon", bmp: "image/bmp", avif: "image/avif",
+};
+
+function resolveSessionPath(
+  sessionManager: SessionManager,
+  sessionId: string,
+  relPath: string,
+): { fullPath: string; session: ReturnType<SessionManager["get"]> & {} } | Response {
+  const session = sessionManager.get(sessionId);
+  if (!session) return jsonResponse({ error: "Session not found" }, 404);
+
+  const fullPath = resolve(join(session.projectRoot, relPath));
+  if (!fullPath.startsWith(resolve(session.projectRoot))) {
+    return jsonResponse({ error: "Path traversal rejected" }, 403);
+  }
+
+  return { fullPath, session };
+}
+
+export function createFileHandlers(sessionManager: SessionManager): Route[] {
+  async function handleFileServe(_req: Request, url: URL): Promise<Response> {
+    const sessionId = url.searchParams.get("session");
+    const relPath = url.searchParams.get("path");
+    if (!sessionId || !relPath) return jsonResponse({ error: "Missing session or path" }, 400);
+
+    const resolved = resolveSessionPath(sessionManager, sessionId, relPath);
+    if (resolved instanceof Response) return resolved;
+
+    try {
+      const file = Bun.file(resolved.fullPath);
+      const stat = await file.exists();
+      if (!stat) return jsonResponse({ error: "File not found" }, 404);
+      if (file.size > 1024 * 1024) return jsonResponse({ error: "File too large" }, 413);
+
+      const content = await file.text();
+      const ext = relPath.split(".").pop() || "";
+      return jsonResponse({ content, language: LANG_MAP[ext] || "text" });
+    } catch {
+      return jsonResponse({ error: "Failed to read file" }, 500);
+    }
+  }
+
+  async function handleImageServe(_req: Request, url: URL): Promise<Response> {
+    const sessionId = url.searchParams.get("session");
+    const relPath = url.searchParams.get("path");
+    if (!sessionId || !relPath) return jsonResponse({ error: "Missing session or path" }, 400);
+
+    const resolved = resolveSessionPath(sessionManager, sessionId, relPath);
+    if (resolved instanceof Response) return resolved;
+
+    try {
+      const file = Bun.file(resolved.fullPath);
+      if (!(await file.exists())) return jsonResponse({ error: "File not found" }, 404);
+      if (file.size > 10 * 1024 * 1024) return jsonResponse({ error: "File too large" }, 413);
+
+      const ext = relPath.split(".").pop()?.toLowerCase() || "";
+      const mime = IMAGE_MIME[ext];
+      if (!mime) return jsonResponse({ error: "Unsupported image format" }, 415);
+
+      return new Response(file, {
+        headers: {
+          "Content-Type": mime,
+          "Cache-Control": "public, max-age=300",
+        },
+      });
+    } catch {
+      return jsonResponse({ error: "Failed to read file" }, 500);
+    }
+  }
+
+  async function handleTreeServe(_req: Request, url: URL): Promise<Response> {
+    const sessionId = url.searchParams.get("session");
+    const relPath = url.searchParams.get("path") || "";
+    if (!sessionId) return jsonResponse({ error: "Missing session" }, 400);
+
+    const resolved = resolveSessionPath(sessionManager, sessionId, relPath);
+    if (resolved instanceof Response) return resolved;
+
+    const ignoreDirs = new Set([".git", "node_modules", ".next", "__pycache__", "dist", ".cache"]);
+
+    try {
+      const dirents = await readdir(resolved.fullPath, { withFileTypes: true });
+      const entries = dirents
+        .filter((d) => !ignoreDirs.has(d.name) && !d.name.startsWith("."))
+        .map((d) => ({
+          name: d.name,
+          type: d.isDirectory() ? "dir" : "file",
+        }))
+        .sort((a, b) => {
+          if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+          return a.name.localeCompare(b.name);
+        });
+      return jsonResponse({ entries });
+    } catch {
+      return jsonResponse({ error: "Failed to read directory" }, 500);
+    }
+  }
+
+  return [
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/file" }), handler: handleFileServe },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/image" }), handler: handleImageServe },
+    { method: "GET", pattern: new URLPattern({ pathname: "/api/tree" }), handler: handleTreeServe },
+  ];
+}

package/daemon/src/handlers/static.ts

@@ -0,0 +1,61 @@
+import { join, dirname } from "path";
+import { DATA_DIR } from "../paths";
+import type { Route } from "../router";
+
+const MIME_TYPES: Record<string, string> = {
+  js: "application/javascript",
+  css: "text/css",
+  html: "text/html",
+  svg: "image/svg+xml",
+  png: "image/png",
+};
+
+let cachedDistDir: string | null = null;
+async function getDistDir(): Promise<string> {
+  if (cachedDistDir) return cachedDistDir;
+  // import.meta.dir = daemon/src/handlers/, go up two levels to daemon/
+  const localDist = join(dirname(import.meta.dir), "..", "dist");
+  if (await Bun.file(join(localDist, "index.html")).exists()) {
+    cachedDistDir = localDist;
+  } else {
+    cachedDistDir = join(DATA_DIR, "daemon");
+  }
+  return cachedDistDir;
+}
+
+async function serveSessionPage(): Promise<Response> {
+  const distDir = await getDistDir();
+  const file = Bun.file(join(distDir, "index.html"));
+  if (await file.exists()) {
+    return new Response(file, { headers: { "Content-Type": "text/html" } });
+  }
+  return new Response("Build not found. Run: bun run daemon/build.ts", { status: 500 });
+}
+
+async function serveStaticAsset(_req: Request, url: URL): Promise<Response> {
+  const path = url.pathname;
+  const distDir = await getDistDir();
+  const assetPath = join(distDir, path.replace("/assets/", ""));
+  const file = Bun.file(assetPath);
+  if (!(await file.exists())) return new Response("Not found", { status: 404 });
+
+  const ext = path.split(".").pop() || "";
+  return new Response(file, {
+    headers: { "Content-Type": MIME_TYPES[ext] || "application/octet-stream" },
+  });
+}
+
+export function createStaticHandlers(): Route[] {
+  return [
+    {
+      method: "GET",
+      pattern: new URLPattern({ pathname: "/s/:id" }),
+      handler: serveSessionPage,
+    },
+    {
+      method: "GET",
+      pattern: new URLPattern({ pathname: "/assets/*" }),
+      handler: serveStaticAsset,
+    },
+  ];
+}

package/daemon/src/handlers/utils.ts

@@ -0,0 +1,14 @@
+export function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export function corsHeaders(port: number): Record<string, string> {
+  return {
+    "Access-Control-Allow-Origin": "http://localhost:" + port,
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+  };
+}

package/daemon/src/router.ts

@@ -0,0 +1,16 @@
+export type RouteHandler = (req: Request, url: URL, match: URLPatternResult) => Response | Promise<Response>;
+
+export interface Route {
+  method: string;
+  pattern: URLPattern;
+  handler: RouteHandler;
+}
+
+export function dispatch(routes: Route[], req: Request, url: URL): Response | Promise<Response> | null {
+  for (const route of routes) {
+    if (route.method !== req.method) continue;
+    const match = route.pattern.exec(url);
+    if (match) return route.handler(req, url, match);
+  }
+  return null;
+}