@popmelt.com/core 0.1.0

package/dist/server.mjs

@@ -0,0 +1,1745 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+
+// src/server/bridge-server.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2, readdir, stat, unlink, writeFile as writeFile2 } from "fs/promises";
+import { createServer } from "http";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+
+// src/server/claude-spawner.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+function spawnClaude(jobId, options) {
+  const {
+    prompt,
+    projectRoot,
+    maxTurns = 10,
+    maxBudgetUsd = 1,
+    allowedTools = ["Read", "Edit", "Write", "Glob", "Grep", "Bash"],
+    claudePath = "claude",
+    resumeSessionId,
+    model,
+    onEvent
+  } = options;
+  const args = [];
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId, "-p", prompt);
+  } else {
+    args.push("-p", prompt);
+  }
+  args.push(
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--max-turns",
+    String(maxTurns),
+    "--max-budget-usd",
+    String(maxBudgetUsd)
+  );
+  if (model) {
+    args.push("--model", model);
+  }
+  for (const tool of allowedTools) {
+    args.push("--allowedTools", tool);
+  }
+  const child = spawn(claudePath, args, {
+    cwd: projectRoot,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: __spreadProps(__spreadValues({}, process.env), { ANTHROPIC_API_KEY: void 0 })
+  });
+  const result = new Promise((resolve) => {
+    var _a;
+    let capturedSessionId;
+    const textChunks = [];
+    const fileEdits = [];
+    let hadError = false;
+    let errorMessage = "";
+    const rl = createInterface({ input: child.stdout });
+    const seenEventTypes = /* @__PURE__ */ new Set();
+    rl.on("line", (line) => {
+      var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
+      if (!line.trim()) return;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.session_id && !capturedSessionId) {
+          capturedSessionId = parsed.session_id;
+        }
+        const topType = (_b = parsed.type) != null ? _b : ((_a2 = parsed.event) == null ? void 0 : _a2.type) ? `event.${parsed.event.type}` : "unknown";
+        seenEventTypes.add(topType);
+        if (parsed.type === "result" && parsed.result && textChunks.length === 0) {
+          const resultText = typeof parsed.result === "string" ? parsed.result : "";
+          if (resultText) {
+            textChunks.push(resultText);
+            onEvent == null ? void 0 : onEvent({ type: "delta", jobId, text: resultText }, jobId);
+          }
+        }
+        if (parsed.type === "assistant" && Array.isArray((_c = parsed.message) == null ? void 0 : _c.content)) {
+          for (const block of parsed.message.content) {
+            if (block.type === "text" && block.text) {
+              textChunks.push(block.text);
+              onEvent == null ? void 0 : onEvent({ type: "delta", jobId, text: block.text }, jobId);
+            }
+            if (block.type === "tool_use" && block.name) {
+              const file = ((_d = block.input) == null ? void 0 : _d.file_path) || ((_e = block.input) == null ? void 0 : _e.path) || void 0;
+              onEvent == null ? void 0 : onEvent(__spreadValues({ type: "tool_use", jobId, tool: block.name }, file ? { file } : {}), jobId);
+              if (block.name === "Edit" && ((_f = block.input) == null ? void 0 : _f.file_path)) {
+                fileEdits.push({
+                  tool: "Edit",
+                  file_path: block.input.file_path,
+                  old_string: block.input.old_string,
+                  new_string: block.input.new_string,
+                  replace_all: block.input.replace_all
+                });
+              } else if (block.name === "Write" && ((_g = block.input) == null ? void 0 : _g.file_path)) {
+                fileEdits.push({
+                  tool: "Write",
+                  file_path: block.input.file_path,
+                  content: block.input.content
+                });
+              }
+            }
+            if (block.type === "thinking" && block.thinking) {
+              onEvent == null ? void 0 : onEvent({ type: "thinking", jobId, text: block.thinking }, jobId);
+            }
+          }
+        }
+        if (parsed.type === "user" && ((_i = (_h = parsed.tool_use_result) == null ? void 0 : _h.file) == null ? void 0 : _i.filePath)) {
+          onEvent == null ? void 0 : onEvent({ type: "tool_use", jobId, tool: "Read", file: parsed.tool_use_result.file.filePath }, jobId);
+        }
+      } catch (e) {
+      }
+    });
+    const stderrChunks = [];
+    (_a = child.stderr) == null ? void 0 : _a.on("data", (chunk) => {
+      stderrChunks.push(chunk.toString());
+    });
+    child.on("close", (code) => {
+      rl.close();
+      if (code !== 0 && code !== null) {
+        hadError = true;
+        errorMessage = stderrChunks.join("") || `Claude process exited with code ${code}`;
+      }
+      resolve({
+        sessionId: capturedSessionId,
+        text: textChunks.join(""),
+        success: !hadError,
+        error: hadError ? errorMessage : void 0,
+        fileEdits: fileEdits.length > 0 ? fileEdits : void 0
+      });
+    });
+    child.on("error", (err) => {
+      hadError = true;
+      errorMessage = err.message;
+      resolve({
+        sessionId: capturedSessionId,
+        text: textChunks.join(""),
+        success: false,
+        error: errorMessage,
+        fileEdits: fileEdits.length > 0 ? fileEdits : void 0
+      });
+    });
+  });
+  return { process: child, result };
+}
+
+// src/server/codex-spawner.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+function spawnCodex(jobId, options) {
+  const {
+    prompt,
+    projectRoot,
+    screenshotPath,
+    resumeSessionId,
+    model,
+    onEvent
+  } = options;
+  const args = [];
+  if (resumeSessionId) {
+    args.push("exec", "resume", resumeSessionId);
+    if (model) args.push("-m", model);
+    args.push("--json", "--full-auto", prompt);
+    if (screenshotPath) {
+      args.push("--image", screenshotPath);
+    }
+  } else {
+    args.push("exec", "--json", "--full-auto");
+    if (model) args.push("-m", model);
+    args.push(prompt);
+    if (screenshotPath) {
+      args.push("--image", screenshotPath);
+    }
+  }
+  const child = spawn2("codex", args, {
+    cwd: projectRoot,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: __spreadValues({}, process.env)
+  });
+  const result = new Promise((resolve) => {
+    var _a;
+    let capturedSessionId;
+    const textChunks = [];
+    let hadError = false;
+    let errorMessage = "";
+    const rl = createInterface2({ input: child.stdout });
+    const seenEventTypes = /* @__PURE__ */ new Set();
+    rl.on("line", (line) => {
+      var _a2, _b, _c, _d;
+      if (!line.trim()) return;
+      try {
+        const parsed = JSON.parse(line);
+        const eventType = (_a2 = parsed.type) != null ? _a2 : "unknown";
+        seenEventTypes.add(eventType);
+        if (eventType === "thread.started" && parsed.thread_id && !capturedSessionId) {
+          capturedSessionId = parsed.thread_id;
+        }
+        if (eventType === "item/agentMessage/delta" && ((_b = parsed.delta) == null ? void 0 : _b.text)) {
+          textChunks.push(parsed.delta.text);
+          onEvent == null ? void 0 : onEvent({ type: "delta", jobId, text: parsed.delta.text }, jobId);
+        }
+        if (eventType === "item/reasoning/delta" && ((_c = parsed.delta) == null ? void 0 : _c.text)) {
+          onEvent == null ? void 0 : onEvent({ type: "thinking", jobId, text: parsed.delta.text }, jobId);
+        }
+        if (eventType === "item/started" && parsed.item) {
+          const itemType = parsed.item.type;
+          if (itemType === "command_execution") {
+            onEvent == null ? void 0 : onEvent({ type: "tool_use", jobId, tool: "Bash" }, jobId);
+          } else if (itemType === "file_change") {
+            const file = parsed.item.filename || parsed.item.path;
+            onEvent == null ? void 0 : onEvent(__spreadValues({ type: "tool_use", jobId, tool: "Edit" }, file ? { file } : {}), jobId);
+          } else if (itemType === "file_read") {
+            const file = parsed.item.filename || parsed.item.path;
+            onEvent == null ? void 0 : onEvent(__spreadValues({ type: "tool_use", jobId, tool: "Read" }, file ? { file } : {}), jobId);
+          } else if (itemType === "web_search") {
+            onEvent == null ? void 0 : onEvent({ type: "tool_use", jobId, tool: "WebSearch" }, jobId);
+          } else if (itemType === "mcp_tool_call") {
+            const toolName = parsed.item.tool_name || parsed.item.name || "MCP";
+            onEvent == null ? void 0 : onEvent({ type: "tool_use", jobId, tool: toolName }, jobId);
+          }
+        }
+        if (eventType === "item/completed" && parsed.item) {
+          if (parsed.item.type === "agent_message") {
+            const itemText = parsed.item.text;
+            if (typeof itemText === "string" && itemText) {
+              textChunks.push(itemText);
+            }
+          } else if (parsed.item.type === "reasoning") {
+            const reasoningText = parsed.item.text;
+            if (typeof reasoningText === "string" && reasoningText) {
+              onEvent == null ? void 0 : onEvent({ type: "thinking", jobId, text: reasoningText }, jobId);
+            }
+          }
+        }
+        if (eventType === "turn.failed") {
+          hadError = true;
+          errorMessage = ((_d = parsed.error) == null ? void 0 : _d.message) || parsed.message || "Turn failed";
+        }
+      } catch (e) {
+      }
+    });
+    const stderrChunks = [];
+    (_a = child.stderr) == null ? void 0 : _a.on("data", (chunk) => {
+      stderrChunks.push(chunk.toString());
+    });
+    child.on("close", (code) => {
+      rl.close();
+      if (code !== 0 && code !== null) {
+        hadError = true;
+        errorMessage = stderrChunks.join("") || `Codex process exited with code ${code}`;
+      }
+      resolve({
+        sessionId: capturedSessionId,
+        text: textChunks.join(""),
+        success: !hadError,
+        error: hadError ? errorMessage : void 0
+      });
+    });
+    child.on("error", (err) => {
+      hadError = true;
+      errorMessage = err.message;
+      resolve({
+        sessionId: capturedSessionId,
+        text: textChunks.join(""),
+        success: false,
+        error: errorMessage
+      });
+    });
+  });
+  return { process: child, result };
+}
+
+// src/server/multipart.ts
+async function parseMultipart(req) {
+  const contentType = req.headers["content-type"] || "";
+  const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
+  if (!boundaryMatch) {
+    throw new Error("Missing multipart boundary");
+  }
+  const boundary = boundaryMatch[1] || boundaryMatch[2];
+  const body = await readBody(req);
+  const delimiter = Buffer.from(`--${boundary}`);
+  const endDelimiter = Buffer.from(`--${boundary}--`);
+  let screenshot;
+  let feedback;
+  let color;
+  let provider;
+  let model;
+  let goal;
+  let pageUrl;
+  let viewport;
+  let planId;
+  let manifest;
+  let tasks;
+  let offset = 0;
+  const parts = [];
+  while (offset < body.length) {
+    const delimStart = body.indexOf(delimiter, offset);
+    if (delimStart === -1) break;
+    const afterDelim = delimStart + delimiter.length;
+    if (body.slice(delimStart, delimStart + endDelimiter.length).equals(endDelimiter)) {
+      break;
+    }
+    let headerStart = afterDelim;
+    if (body[headerStart] === 13 && body[headerStart + 1] === 10) {
+      headerStart += 2;
+    }
+    const headerEnd = body.indexOf("\r\n\r\n", headerStart);
+    if (headerEnd === -1) break;
+    const headers = body.slice(headerStart, headerEnd).toString("utf-8");
+    const bodyStart = headerEnd + 4;
+    const nextDelim = body.indexOf(delimiter, bodyStart);
+    const bodyEnd = nextDelim !== -1 ? nextDelim - 2 : body.length;
+    parts.push({
+      headers,
+      body: body.slice(bodyStart, bodyEnd)
+    });
+    offset = nextDelim !== -1 ? nextDelim : body.length;
+  }
+  for (const part of parts) {
+    const nameMatch = part.headers.match(/name="([^"]+)"/);
+    if (!nameMatch) continue;
+    const name = nameMatch[1];
+    if (name === "screenshot") {
+      screenshot = part.body;
+    } else if (name === "feedback") {
+      feedback = part.body.toString("utf-8");
+    } else if (name === "color") {
+      color = part.body.toString("utf-8");
+    } else if (name === "provider") {
+      provider = part.body.toString("utf-8");
+    } else if (name === "model") {
+      model = part.body.toString("utf-8");
+    } else if (name === "goal") {
+      goal = part.body.toString("utf-8");
+    } else if (name === "pageUrl") {
+      pageUrl = part.body.toString("utf-8");
+    } else if (name === "viewport") {
+      viewport = part.body.toString("utf-8");
+    } else if (name === "planId") {
+      planId = part.body.toString("utf-8");
+    } else if (name === "manifest") {
+      manifest = part.body.toString("utf-8");
+    } else if (name === "tasks") {
+      tasks = part.body.toString("utf-8");
+    }
+  }
+  if (!screenshot) throw new Error("Missing screenshot field");
+  if (!feedback) feedback = "";
+  return { screenshot, feedback, color, provider, model, goal, pageUrl, viewport, planId, manifest, tasks };
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+// src/server/prompt-builder.ts
+function formatFeedbackContext(feedback) {
+  var _a;
+  const lines = [];
+  if (feedback.annotations.length > 0) {
+    lines.push("## Annotations");
+    for (const ann of feedback.annotations) {
+      const elementsDesc = ann.elements.map((el) => {
+        const parts = [el.selector];
+        if (el.reactComponent) parts.push(`(${el.reactComponent})`);
+        return parts.join(" ");
+      }).join(", ");
+      const instruction = ann.instruction || "No text";
+      lines.push(`- id=${ann.id} [${ann.type}] ${instruction} \u2192 Elements: ${elementsDesc || "none"}`);
+    }
+  }
+  if (feedback.styleModifications.length > 0) {
+    lines.push("");
+    lines.push("## Style Changes (make permanent in source)");
+    lines.push("The developer previewed these CSS changes via inline style overrides. Find the corresponding styles in the source files and update them so the changes persist:");
+    for (const mod of feedback.styleModifications) {
+      const elementDesc = ((_a = mod.element) == null ? void 0 : _a.reactComponent) ? `(${mod.element.reactComponent})` : "";
+      for (const change of mod.changes) {
+        lines.push(
+          `- ${mod.selector} ${elementDesc}: ${change.property} ${change.original} \u2192 ${change.modified}`
+        );
+      }
+    }
+  }
+  if (feedback.inspectedElement) {
+    const el = feedback.inspectedElement;
+    lines.push("");
+    lines.push("## Inspected Element");
+    lines.push("The developer has this element selected in the inspector:");
+    const parts = [el.selector];
+    if (el.reactComponent) parts.push(`(${el.reactComponent})`);
+    if (el.context) parts.push(`in ${el.context}`);
+    if (el.textContent) parts.push(`"${el.textContent.slice(0, 80)}"`);
+    lines.push(`- ${parts.join(" ")}`);
+  }
+  return lines.join("\n");
+}
+function buildPrompt(screenshotPath, feedback, options) {
+  const lines = [];
+  lines.push("You are reviewing a UI screenshot with developer annotations.");
+  lines.push("");
+  if ((options == null ? void 0 : options.provider) !== "codex") {
+    lines.push(`IMPORTANT: First, use the Read tool to view the screenshot at: ${screenshotPath}`);
+    lines.push("");
+  }
+  lines.push(
+    `The developer annotated their running app at ${feedback.url} (${feedback.viewport.width}x${feedback.viewport.height}).`
+  );
+  if ((options == null ? void 0 : options.threadHistory) && options.threadHistory.length > 0) {
+    lines.push("");
+    lines.push("## Previous Conversation");
+    let roundNum = 0;
+    for (const msg of options.threadHistory) {
+      if (msg.role === "human") {
+        roundNum++;
+        if (msg.replyToQuestion) {
+          lines.push(`### Round ${roundNum} (human) \u2014 reply`);
+          lines.push(`"${msg.replyToQuestion}"`);
+        } else {
+          lines.push(`### Round ${roundNum} (human)`);
+          if (msg.feedbackSummary) {
+            lines.push(`Annotations: ${msg.feedbackSummary}`);
+          }
+          if (msg.annotationIds && msg.annotationIds.length > 0) {
+            lines.push(`Annotation IDs: ${msg.annotationIds.join(", ")}`);
+          }
+        }
+      } else {
+        if (msg.question) {
+          lines.push(`### Round ${roundNum} (assistant) \u2014 question`);
+          lines.push(`"${msg.question}"`);
+        } else {
+          lines.push(`### Round ${roundNum} (assistant)`);
+          if (msg.responseText) {
+            lines.push(`Response: ${msg.responseText}`);
+          }
+          if (msg.resolutions && msg.resolutions.length > 0) {
+            for (const r of msg.resolutions) {
+              lines.push(`- ${r.annotationId}: ${r.status} \u2014 ${r.summary}`);
+              if (r.filesModified && r.filesModified.length > 0) {
+                lines.push(`  Files: ${r.filesModified.join(", ")}`);
+              }
+            }
+          }
+          if (msg.toolsUsed && msg.toolsUsed.length > 0) {
+            lines.push(`Tools used: ${msg.toolsUsed.join(", ")}`);
+          }
+        }
+      }
+    }
+    lines.push("");
+    lines.push("The current round is shown in full below.");
+  }
+  const feedbackContext = formatFeedbackContext(feedback);
+  if (feedbackContext) {
+    lines.push("");
+    lines.push(feedbackContext);
+  }
+  lines.push("");
+  lines.push(
+    "Follow the developer's instructions. If they ask for changes, apply them to the source files \u2014 the dev server has HMR so changes appear immediately. If they ask a question or request analysis, respond in text without modifying code."
+  );
+  lines.push("");
+  lines.push(
+    "IMPORTANT: If any elements you modify have a `data-pm` attribute, preserve it in the source. This attribute tracks annotation positions."
+  );
+  lines.push("");
+  lines.push("## Resolution");
+  lines.push("After completing all work, output a resolution block listing what you did for each annotation:");
+  lines.push("<resolution>");
+  lines.push('[{"annotationId":"<id>","status":"resolved","summary":"<what you did>","filesModified":["<file>"]}]');
+  lines.push("</resolution>");
+  lines.push(`Use status "resolved" when the change is complete, or "needs_review" if you're unsure about the result.`);
+  lines.push("");
+  lines.push("## Questions");
+  lines.push("If the annotation text is unclear, ambiguous, gibberish, or you are unsure what the developer wants, output a question:");
+  lines.push('<question>What do you mean by "..."?</question>');
+  lines.push("Do NOT guess what unclear instructions mean \u2014 ask instead.");
+  lines.push("You may output BOTH a <resolution> for clear annotations AND a <question> for unclear ones in the same response.");
+  return lines.join("\n");
+}
+function parseQuestion(responseText) {
+  var _a;
+  const match = responseText.match(/<question>\s*([\s\S]*?)\s*<\/question>/);
+  return (_a = match == null ? void 0 : match[1]) != null ? _a : null;
+}
+function buildReplyPrompt(screenshotPath, threadHistory, provider) {
+  const lines = [];
+  lines.push("You are continuing work on a UI based on the developer's reply to your question.");
+  lines.push("");
+  if (provider !== "codex") {
+    lines.push(`IMPORTANT: First, use the Read tool to view the screenshot at: ${screenshotPath}`);
+  }
+  const firstHuman = threadHistory.find((m) => m.role === "human" && m.feedbackContext);
+  if (firstHuman == null ? void 0 : firstHuman.feedbackContext) {
+    lines.push("");
+    lines.push(firstHuman.feedbackContext);
+  }
+  if (threadHistory.length > 0) {
+    lines.push("");
+    lines.push("## Conversation History");
+    let roundNum = 0;
+    for (const msg of threadHistory) {
+      if (msg.role === "human") {
+        roundNum++;
+        if (msg.replyToQuestion) {
+          lines.push(`### Round ${roundNum} (human) \u2014 reply`);
+          lines.push(`"${msg.replyToQuestion}"`);
+        } else {
+          lines.push(`### Round ${roundNum} (human)`);
+          if (msg.feedbackSummary) {
+            lines.push(`Annotations: ${msg.feedbackSummary}`);
+          }
+        }
+      } else {
+        if (msg.question) {
+          lines.push(`### Round ${roundNum} (assistant) \u2014 question`);
+          lines.push(`"${msg.question}"`);
+        } else {
+          lines.push(`### Round ${roundNum} (assistant)`);
+          if (msg.responseText) {
+            lines.push(`Response: ${msg.responseText}`);
+          }
+        }
+      }
+    }
+  }
+  lines.push("");
+  lines.push("The developer answered your question. Continue working based on their reply.");
+  lines.push("Follow their instructions \u2014 apply code changes only if requested. The dev server has HMR so changes appear immediately.");
+  lines.push("");
+  lines.push("IMPORTANT: If any elements you modify have a `data-pm` attribute, preserve it in the source. This attribute tracks annotation positions.");
+  lines.push("");
+  lines.push("## Resolution");
+  lines.push("After completing all work, output a resolution block listing what you did for each annotation:");
+  lines.push("<resolution>");
+  lines.push('[{"annotationId":"<id>","status":"resolved","summary":"<what you did>","filesModified":["<file>"]}]');
+  lines.push("</resolution>");
+  lines.push(`Use status "resolved" when the change is complete, or "needs_review" if you're unsure about the result.`);
+  lines.push("");
+  lines.push("## Questions");
+  lines.push("If you still need clarification, output:");
+  lines.push("<question>Your question here</question>");
+  lines.push("You may output BOTH a <resolution> and a <question> in the same response.");
+  return lines.join("\n");
+}
+function isValidResolution(r) {
+  return typeof r === "object" && r !== null && typeof r.annotationId === "string" && (r.status === "resolved" || r.status === "needs_review") && typeof r.summary === "string";
+}
+function parseResolutions(responseText) {
+  const match = responseText.match(/<resolution>\s*([\s\S]*?)\s*<\/resolution>/);
+  if (!match || !match[1]) return [];
+  try {
+    const parsed = JSON.parse(match[1]);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isValidResolution);
+  } catch (e) {
+    return [];
+  }
+}
+function parseAllResolutions(responseText) {
+  const results = [];
+  const regex = /<resolution>\s*([\s\S]*?)\s*<\/resolution>/g;
+  let match;
+  while ((match = regex.exec(responseText)) !== null) {
+    if (!match[1]) continue;
+    try {
+      const parsed = JSON.parse(match[1]);
+      if (Array.isArray(parsed)) {
+        results.push(...parsed.filter(isValidResolution));
+      }
+    } catch (e) {
+    }
+  }
+  return results;
+}
+function buildPlannerPrompt(screenshotPath, goal, pageUrl, viewport, manifestJson, feedbackContext) {
+  const lines = [];
+  lines.push("You are a UI design planner. You are looking at a full-page screenshot of a web application.");
+  lines.push("");
+  lines.push(`IMPORTANT: First, use the Read tool to view the screenshot at: ${screenshotPath}`);
+  lines.push("");
+  lines.push(`Page: ${pageUrl}`);
+  lines.push(`Viewport: ${viewport.width}x${viewport.height}`);
+  if (manifestJson) {
+    lines.push("");
+    lines.push("## Page Elements (ground truth)");
+    lines.push("Below is a structured inventory of actual DOM elements on this page. Cross-reference");
+    lines.push("against this list \u2014 do NOT reference elements that aren't listed here.");
+    lines.push("");
+    lines.push("<manifest>");
+    lines.push(manifestJson);
+    lines.push("</manifest>");
+  }
+  if (feedbackContext) {
+    lines.push("");
+    lines.push("## Developer Context");
+    lines.push("The developer has the following annotations and style changes on their canvas. Factor these into your plan:");
+    lines.push(feedbackContext);
+  }
+  lines.push("");
+  lines.push("## Goal");
+  lines.push(goal);
+  lines.push("");
+  lines.push("## Your Task");
+  lines.push("Analyze the screenshot and decompose the goal into specific, element-level tasks.");
+  lines.push("Each task targets a specific region of the page and gives a clear instruction for a worker agent.");
+  lines.push("");
+  lines.push("Output your plan as a JSON array inside a <plan> tag. Each task has:");
+  lines.push('- `id`: A short unique identifier (e.g., "t1", "t2")');
+  lines.push("- `instruction`: Clear, specific instruction for a worker agent (what to change and how)");
+  lines.push("- `region`: Bounding box in page coordinates `{x, y, width, height}` \u2014 where (x,y) is top-left corner");
+  lines.push("- `priority`: Optional 1-5 (1=highest). Tasks with no dependency can share a priority level.");
+  lines.push("");
+  lines.push("Example:");
+  lines.push("<plan>");
+  lines.push("[");
+  lines.push('  {"id":"t1","instruction":"Increase heading font-size to 48px and change font-weight to 700","region":{"x":100,"y":50,"width":600,"height":80},"priority":1},');
+  lines.push('  {"id":"t2","instruction":"Add a subtle box-shadow to the card container","region":{"x":80,"y":200,"width":640,"height":300},"priority":2}');
+  lines.push("]");
+  lines.push("</plan>");
+  lines.push("");
+  lines.push("Guidelines:");
+  lines.push("- CRITICAL: Cross-check all element references against the <manifest>. Only reference elements that actually exist. Use the manifest's text content, component names, and bounding rects for precise instructions.");
+  lines.push('- Be specific about values (colors, sizes, spacing) rather than vague ("make it look better")');
+  lines.push("- Each task should be independently actionable by a worker that can only see its region");
+  lines.push("- Regions should tightly bound the relevant UI element(s)");
+  lines.push("- Keep tasks atomic \u2014 one change per task, not multiple unrelated changes");
+  lines.push("- Order by priority: structural changes first, then visual polish");
+  lines.push("- If the goal can be accomplished as a single change, return a plan with just one task. Only decompose when the goal genuinely requires multiple independent changes.");
+  lines.push("- If the goal is unclear or you need more context, output a question instead:");
+  lines.push("<question>Your question here</question>");
+  lines.push("");
+  lines.push("Do NOT modify any files. You are a planner only \u2014 output a <plan> or <question>, nothing else.");
+  return lines.join("\n");
+}
+function parsePlan(responseText) {
+  const match = responseText.match(/<plan>\s*([\s\S]*?)\s*<\/plan>/);
+  if (!(match == null ? void 0 : match[1])) return null;
+  try {
+    const parsed = JSON.parse(match[1]);
+    if (!Array.isArray(parsed)) return null;
+    return parsed.filter(
+      (t) => {
+        if (typeof t !== "object" || t === null) return false;
+        const obj = t;
+        if (typeof obj.id !== "string" || typeof obj.instruction !== "string") return false;
+        if (typeof obj.region !== "object" || obj.region === null) return false;
+        const r = obj.region;
+        return typeof r.x === "number" && typeof r.y === "number" && typeof r.width === "number" && typeof r.height === "number";
+      }
+    );
+  } catch (e) {
+    return null;
+  }
+}
+function buildReviewerPrompt(screenshotPath, goal, completedTasks) {
+  const lines = [];
+  lines.push("You are reviewing whether a series of UI changes achieved the original design goal.");
+  lines.push("");
+  lines.push(`IMPORTANT: First, use the Read tool to view the screenshot at: ${screenshotPath}`);
+  lines.push("");
+  lines.push("## Original Goal");
+  lines.push(goal);
+  lines.push("");
+  lines.push("## Completed Tasks");
+  for (const task of completedTasks) {
+    lines.push(`- [${task.id}] ${task.instruction} \u2192 ${task.summary}`);
+  }
+  lines.push("");
+  lines.push("## Your Task");
+  lines.push("Look at the current screenshot and determine if the goal has been achieved.");
+  lines.push("Output your verdict inside a <review> tag:");
+  lines.push("<review>");
+  lines.push('{"verdict":"pass","summary":"The changes look good..."}');
+  lines.push("</review>");
+  lines.push("");
+  lines.push("Or if issues remain:");
+  lines.push("<review>");
+  lines.push('{"verdict":"fail","summary":"Some issues remain...","issues":["Issue 1","Issue 2"]}');
+  lines.push("</review>");
+  lines.push("");
+  lines.push("Do NOT modify any files. Output only a <review> block.");
+  return lines.join("\n");
+}
+function buildPlanExecutorPrompt(screenshotPath, tasks, pageUrl, viewport, provider) {
+  const lines = [];
+  lines.push("You are implementing a series of UI changes on a web application.");
+  lines.push("");
+  if (provider !== "codex") {
+    lines.push(`IMPORTANT: First, use the Read tool to view the screenshot at: ${screenshotPath}`);
+    lines.push("");
+  }
+  lines.push(`Page: ${pageUrl} (${viewport.width}x${viewport.height})`);
+  lines.push("");
+  lines.push("## Tasks");
+  lines.push("Each task targets a specific region of the page. Complete them in order.");
+  lines.push("");
+  for (const task of tasks) {
+    lines.push(`### Task ${task.planTaskId} (annotationId: ${task.annotationId})`);
+    lines.push(`Instruction: ${task.instruction}`);
+    lines.push(`Region: (${task.region.x}, ${task.region.y}) ${task.region.width}x${task.region.height}`);
+    if (task.linkedSelector) {
+      lines.push(`Target element: ${task.linkedSelector}`);
+    }
+    if (task.elements && task.elements.length > 0) {
+      const elemDesc = task.elements.map((el) => {
+        const parts = [el.selector];
+        if (el.reactComponent) parts.push(`(${el.reactComponent})`);
+        return parts.join(" ");
+      }).join(", ");
+      lines.push(`Elements: ${elemDesc}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Instructions");
+  lines.push("- Apply each change to the source files \u2014 the dev server has HMR so changes appear immediately.");
+  lines.push("- IMPORTANT: If any elements you modify have a `data-pm` attribute, preserve it in the source.");
+  lines.push("- You may use parallel subagents (Task tool) for independent changes, or work serially \u2014 use your judgment.");
+  lines.push("");
+  lines.push("## Resolution");
+  lines.push("CRITICAL: After completing EACH task, immediately output a <resolution> block for that task.");
+  lines.push("Do NOT wait until all tasks are done \u2014 output each resolution as soon as that task is finished.");
+  lines.push("<resolution>");
+  lines.push('[{"annotationId":"<annotationId>","status":"resolved","summary":"<what you did>","filesModified":["<file>"]}]');
+  lines.push("</resolution>");
+  lines.push(`Use status "resolved" when the change is complete, or "needs_review" if you're unsure about the result.`);
+  return lines.join("\n");
+}
+function parseReview(responseText) {
+  const match = responseText.match(/<review>\s*([\s\S]*?)\s*<\/review>/);
+  if (!(match == null ? void 0 : match[1])) return null;
+  try {
+    const parsed = JSON.parse(match[1]);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    if (parsed.verdict !== "pass" && parsed.verdict !== "fail") return null;
+    if (typeof parsed.summary !== "string") return null;
+    return {
+      verdict: parsed.verdict,
+      summary: parsed.summary,
+      issues: Array.isArray(parsed.issues) ? parsed.issues.filter((i) => typeof i === "string") : void 0
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+// src/server/queue.ts
+var JobQueue = class {
+  constructor(maxConcurrency = 5) {
+    this.queue = [];
+    this.activeJobs = /* @__PURE__ */ new Map();
+    this.activeProcesses = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.processor = null;
+    this.maxConcurrency = maxConcurrency;
+  }
+  setProcessor(fn) {
+    this.processor = fn;
+  }
+  /** First active job (backward compat for status endpoint) */
+  get active() {
+    const first = this.activeJobs.values().next();
+    return first.done ? null : first.value;
+  }
+  get allActive() {
+    return Array.from(this.activeJobs.values());
+  }
+  get activeCount() {
+    return this.activeJobs.size;
+  }
+  get depth() {
+    return this.queue.length;
+  }
+  get isRunning() {
+    return this.activeJobs.size > 0;
+  }
+  setActiveProcess(jobId, proc) {
+    if (proc) {
+      this.activeProcesses.set(jobId, proc);
+    } else {
+      this.activeProcesses.delete(jobId);
+    }
+  }
+  enqueue(job) {
+    this.queue.push(job);
+    this.processNext();
+    return this.queue.length + this.activeJobs.size;
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  broadcast(event, jobId) {
+    for (const listener of this.listeners) {
+      listener(event, jobId);
+    }
+  }
+  cancelJob(jobId) {
+    const proc = this.activeProcesses.get(jobId);
+    const job = this.activeJobs.get(jobId);
+    if (!proc || !job) return false;
+    proc.kill("SIGTERM");
+    this.activeProcesses.delete(jobId);
+    this.activeJobs.delete(jobId);
+    job.status = "error";
+    job.error = "Cancelled by user";
+    this.broadcast(
+      { type: "error", jobId: job.id, message: "Cancelled by user" },
+      job.id
+    );
+    this.processNext();
+    return true;
+  }
+  cancelActive() {
+    if (this.activeJobs.size === 0) return false;
+    const jobIds = Array.from(this.activeJobs.keys());
+    for (const jobId of jobIds) {
+      this.cancelJob(jobId);
+    }
+    return true;
+  }
+  destroy() {
+    for (const proc of this.activeProcesses.values()) {
+      proc.kill("SIGTERM");
+    }
+    this.activeProcesses.clear();
+    this.activeJobs.clear();
+    this.queue = [];
+    this.listeners.clear();
+  }
+  processNext() {
+    while (this.activeJobs.size < this.maxConcurrency && this.queue.length > 0 && this.processor) {
+      const job = this.queue.shift();
+      this.activeJobs.set(job.id, job);
+      job.status = "running";
+      this.broadcast({ type: "job_started", jobId: job.id, position: 0 }, job.id);
+      this.processor(job).catch((err) => {
+        job.status = "error";
+        job.error = err instanceof Error ? err.message : String(err);
+        this.broadcast(
+          { type: "error", jobId: job.id, message: job.error },
+          job.id
+        );
+      }).finally(() => {
+        this.activeJobs.delete(job.id);
+        this.activeProcesses.delete(job.id);
+        this.processNext();
+        if (this.activeJobs.size === 0 && this.queue.length === 0) {
+          this.broadcast({ type: "queue_drained" }, job.id);
+        }
+      });
+    }
+  }
+};
+
+// src/server/thread-store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var EMPTY_STORE = { version: 1, threads: {} };
+var ThreadFileStore = class {
+  constructor(projectRoot) {
+    this.cache = null;
+    this.writeChain = Promise.resolve();
+    this.filePath = join(projectRoot, ".popmelt", "threads.json");
+  }
+  async load() {
+    if (this.cache) return this.cache;
+    try {
+      const raw = await readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.version === 1 && parsed.threads) {
+        this.cache = parsed;
+        return this.cache;
+      }
+    } catch (e) {
+    }
+    this.cache = __spreadProps(__spreadValues({}, EMPTY_STORE), { threads: {} });
+    return this.cache;
+  }
+  async getThread(id) {
+    var _a;
+    const store = await this.load();
+    return (_a = store.threads[id]) != null ? _a : null;
+  }
+  async findContinuationThread(linkedSelectors) {
+    if (linkedSelectors.length === 0) return null;
+    const store = await this.load();
+    const selectorSet = new Set(linkedSelectors);
+    for (const thread of Object.values(store.threads)) {
+      const hasOverlap = thread.elementIdentifiers.some((id) => selectorSet.has(id));
+      if (hasOverlap) return thread;
+    }
+    return null;
+  }
+  async createThread(id, linkedSelectors) {
+    const store = await this.load();
+    const thread = {
+      id,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      elementIdentifiers: linkedSelectors,
+      messages: []
+    };
+    store.threads[id] = thread;
+    await this.persist();
+    return thread;
+  }
+  async appendMessage(threadId, message) {
+    const store = await this.load();
+    const thread = store.threads[threadId];
+    if (!thread) return;
+    thread.messages.push(message);
+    thread.updatedAt = Date.now();
+    await this.persist();
+  }
+  async addElementIdentifiers(threadId, selectors) {
+    const store = await this.load();
+    const thread = store.threads[threadId];
+    if (!thread) return;
+    const existing = new Set(thread.elementIdentifiers);
+    for (const sel of selectors) {
+      if (!existing.has(sel)) {
+        thread.elementIdentifiers.push(sel);
+      }
+    }
+    thread.updatedAt = Date.now();
+    await this.persist();
+  }
+  async getThreadHistory(threadId, maxMessages = 6) {
+    const thread = await this.getThread(threadId);
+    if (!thread || thread.messages.length === 0) return [];
+    if (thread.messages.length <= maxMessages) {
+      return thread.messages;
+    }
+    return [
+      thread.messages[0],
+      ...thread.messages.slice(-(maxMessages - 1))
+    ];
+  }
+  async persist() {
+    this.writeChain = this.writeChain.then(async () => {
+      if (!this.cache) return;
+      try {
+        await mkdir(dirname(this.filePath), { recursive: true });
+        await writeFile(this.filePath, JSON.stringify(this.cache, null, 2));
+      } catch (err) {
+        console.error("[ThreadStore] Failed to persist:", err);
+      }
+    });
+    await this.writeChain;
+  }
+};
+
+// src/server/bridge-server.ts
+var DEFAULT_PORT = 1111;
+var DEFAULT_ALLOWED_TOOLS = ["Read", "Edit", "Write", "Glob", "Grep", "Bash", "WebFetch", "WebSearch", "Bash(curl:*)"];
+var CLEANUP_INTERVAL_MS = 30 * 60 * 1e3;
+var MAX_FILE_AGE_MS = 60 * 60 * 1e3;
+function isLocalhostOrigin(origin) {
+  if (!origin) return false;
+  try {
+    const url = new URL(origin);
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  } catch (e) {
+    return false;
+  }
+}
+function setCors(req, res) {
+  const origin = req.headers.origin;
+  if (isLocalhostOrigin(origin)) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  }
+}
+function sendJson(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function ansiColor(hex, text) {
+  if (!hex) return text;
+  const m = hex.match(/^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+  if (!m) return text;
+  const [, r, g, b] = m;
+  return `\x1B[38;2;${parseInt(r, 16)};${parseInt(g, 16)};${parseInt(b, 16)}m${text}\x1B[0m`;
+}
+function sendSSE(client, event) {
+  try {
+    client.res.write(`event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`);
+  } catch (e) {
+  }
+}
+async function createPopmelt(options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const port = (_a = options.port) != null ? _a : DEFAULT_PORT;
+  const projectRoot = (_b = options.projectRoot) != null ? _b : process.cwd();
+  const tempDir = (_c = options.tempDir) != null ? _c : join2(tmpdir(), "popmelt-bridge");
+  const maxTurns = (_d = options.maxTurns) != null ? _d : 10;
+  const maxBudgetUsd = (_e = options.maxBudgetUsd) != null ? _e : 1;
+  const allowedTools = (_f = options.allowedTools) != null ? _f : DEFAULT_ALLOWED_TOOLS;
+  const claudePath = (_g = options.claudePath) != null ? _g : "claude";
+  const defaultProvider = (_h = options.provider) != null ? _h : "claude";
+  const capabilities = {};
+  for (const cli of ["claude", "codex"]) {
+    try {
+      const cliPath = execFileSync("which", [cli], { encoding: "utf-8" }).trim();
+      capabilities[cli] = { available: true, path: cliPath };
+    } catch (e) {
+      capabilities[cli] = { available: false, path: null };
+    }
+  }
+  await mkdir2(tempDir, { recursive: true });
+  cleanupTempDir(tempDir).catch(() => {
+  });
+  const queue = new JobQueue();
+  const sseClients = /* @__PURE__ */ new Set();
+  const threadStore = new ThreadFileStore(projectRoot);
+  const jobGroups = /* @__PURE__ */ new Map();
+  queue.addListener((event, _jobId) => {
+    for (const client of sseClients) {
+      sendSSE(client, event);
+    }
+  });
+  queue.setProcessor(async (job) => {
+    var _a2, _b2, _c2, _d2, _e2, _f2, _g2;
+    const replyPrompt = job._replyPrompt;
+    const provider = (_a2 = job.provider) != null ? _a2 : defaultProvider;
+    let resumeSessionId;
+    if (job.threadId) {
+      const thread = await threadStore.getThread(job.threadId);
+      if (thread) {
+        for (let i = thread.messages.length - 1; i >= 0; i--) {
+          if (thread.messages[i].sessionId) {
+            resumeSessionId = thread.messages[i].sessionId;
+            break;
+          }
+        }
+      }
+    }
+    let prompt;
+    if (resumeSessionId && replyPrompt) {
+      const lastReply = (_b2 = await threadStore.getThread(job.threadId)) == null ? void 0 : _b2.messages.filter((m) => m.role === "human").pop();
+      const replyText = (lastReply == null ? void 0 : lastReply.replyToQuestion) || (lastReply == null ? void 0 : lastReply.feedbackSummary) || "";
+      prompt = replyText + "\n\nAfter completing work, output a <resolution> block. If unclear, output a <question> block.";
+    } else if (resumeSessionId) {
+      prompt = formatFeedbackContext(job.feedback) + "\n\nFollow the developer's instructions. If they ask for changes, apply them to the source files.\n\nAfter completing work, output a <resolution> block. If unclear, output a <question> block." + (provider !== "codex" ? `
+
+IMPORTANT: First, use the Read tool to view the updated screenshot at: ${job.screenshotPath}` : "");
+    } else {
+      const threadHistory = !replyPrompt && job.threadId ? await threadStore.getThreadHistory(job.threadId) : void 0;
+      prompt = replyPrompt != null ? replyPrompt : buildPrompt(job.screenshotPath, job.feedback, {
+        threadHistory: threadHistory && threadHistory.length > 0 ? threadHistory : void 0,
+        provider
+      });
+    }
+    const tag = ansiColor(job.color, `[\u22B9 ${port}:${job.id}]`);
+    console.log(`${tag} Reviewing feedback ${job.screenshotPath} (provider: ${provider})${job.threadId ? ` (thread: ${job.threadId})` : ""}${resumeSessionId ? ` (resuming: ${resumeSessionId.slice(0, 8)})` : ""}`);
+    const isPlanExecutor = !!job._isPlanExecutor;
+    let deltaBuffer = "";
+    let lastResolutionCount = 0;
+    const onEvent = (event, jobId) => {
+      queue.broadcast(event, jobId);
+      if (isPlanExecutor && event.type === "delta" && "text" in event) {
+        deltaBuffer += event.text;
+        const resolutions = parseAllResolutions(deltaBuffer);
+        if (resolutions.length > lastResolutionCount) {
+          const newResolutions = resolutions.slice(lastResolutionCount);
+          lastResolutionCount = resolutions.length;
+          queue.broadcast(
+            { type: "task_resolved", jobId, planId: job.planId, resolutions: newResolutions, threadId: job.threadId },
+            jobId
+          );
+        }
+      }
+    };
+    const jobAllowedTools = (_c2 = job._allowedTools) != null ? _c2 : allowedTools;
+    const { process: proc, result } = provider === "codex" ? spawnCodex(job.id, {
+      prompt,
+      projectRoot,
+      screenshotPath: job.screenshotPath,
+      resumeSessionId,
+      model: job.model,
+      onEvent
+    }) : spawnClaude(job.id, {
+      prompt,
+      projectRoot,
+      maxTurns,
+      maxBudgetUsd,
+      allowedTools: jobAllowedTools,
+      claudePath,
+      resumeSessionId,
+      model: job.model,
+      onEvent
+    });
+    queue.setActiveProcess(job.id, proc);
+    const spawnResult = await result;
+    job.result = spawnResult.text;
+    if (spawnResult.success) {
+      console.log(`${tag} Iteration complete`);
+      if (spawnResult.fileEdits && spawnResult.fileEdits.length > 0) {
+        console.log(`${tag} Captured ${spawnResult.fileEdits.length} file edit(s): ${spawnResult.fileEdits.map((e) => `${e.tool} ${e.file_path}`).join(", ")}`);
+      }
+      job.status = "done";
+      const question = parseQuestion(spawnResult.text);
+      let resolutions = parseResolutions(spawnResult.text);
+      if (resolutions.length > 0 && job.annotationIds && job.annotationIds.length > 0) {
+        const realIdSet = new Set(job.annotationIds);
+        const allMatch = resolutions.every((r) => realIdSet.has(r.annotationId));
+        if (!allMatch) {
+          resolutions = resolutions.map((r, i) => __spreadProps(__spreadValues({}, r), {
+            annotationId: job.annotationIds[i % job.annotationIds.length]
+          }));
+        }
+      }
+      if (job.threadId) {
+        await threadStore.appendMessage(job.threadId, {
+          role: "assistant",
+          timestamp: Date.now(),
+          jobId: job.id,
+          responseText: spawnResult.text,
+          resolutions: resolutions.length > 0 ? resolutions : void 0,
+          question: question != null ? question : void 0,
+          sessionId: spawnResult.sessionId
+        });
+      }
+      if (job.planId && !job.planTaskId) {
+        const group = jobGroups.get(job.planId);
+        if (group) {
+          const plan = parsePlan(spawnResult.text);
+          if (plan && plan.length > 0) {
+            group.plan = plan;
+            group.status = "awaiting_approval";
+            group.plannerThreadId = job.threadId;
+            console.log(`${tag} Plan ready: ${plan.length} tasks for group ${job.planId}`);
+            queue.broadcast(
+              { type: "plan_ready", jobId: job.id, planId: job.planId, tasks: plan, threadId: job.threadId },
+              job.id
+            );
+          } else if (!question) {
+            group.status = "error";
+            console.error(`${tag} Failed to parse plan from planner response`);
+          }
+        }
+      }
+      if (job.planId && job._isReview) {
+        const group = jobGroups.get(job.planId);
+        if (group) {
+          const review = parseReview(spawnResult.text);
+          if (review) {
+            group.status = review.verdict === "pass" ? "done" : "executing";
+            console.log(`${tag} Review verdict: ${review.verdict} \u2014 ${review.summary}`);
+            queue.broadcast(
+              { type: "plan_review", planId: job.planId, verdict: review.verdict, summary: review.summary, issues: review.issues },
+              job.id
+            );
+          }
+        }
+      }
+      if (question) {
+        console.log(`${tag} \u{1F4AC} Question detected: "${question.slice(0, 120)}" \u2192 broadcasting to ${sseClients.size} SSE clients (threadId=${(_d2 = job.threadId) != null ? _d2 : job.id}, annotationIds=${(_f2 = (_e2 = job.annotationIds) == null ? void 0 : _e2.join(",")) != null ? _f2 : "none"})`);
+        queue.broadcast(
+          { type: "question", jobId: job.id, threadId: (_g2 = job.threadId) != null ? _g2 : job.id, question, annotationIds: job.annotationIds },
+          job.id
+        );
+      }
+      queue.broadcast(
+        { type: "done", jobId: job.id, success: true, resolutions: resolutions.length > 0 ? resolutions : void 0, responseText: spawnResult.text, threadId: job.threadId },
+        job.id
+      );
+    } else {
+      console.error(`${tag} Error: ${spawnResult.error}`);
+      job.status = "error";
+      job.error = spawnResult.error;
+      queue.broadcast(
+        {
+          type: "error",
+          jobId: job.id,
+          message: spawnResult.error || "Unknown error"
+        },
+        job.id
+      );
+    }
+  });
+  const server = createServer(async (req, res) => {
+    setCors(req, res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+    const path = url.pathname;
+    try {
+      if (req.method === "POST" && path === "/send") {
+        await handleSend(req, res);
+      } else if (req.method === "GET" && path === "/events") {
+        handleEvents(req, res);
+      } else if (req.method === "GET" && path === "/status") {
+        handleStatus(res);
+      } else if (req.method === "GET" && path === "/capabilities") {
+        sendJson(res, 200, { providers: capabilities });
+      } else if (req.method === "POST" && path === "/reply") {
+        await handleReply(req, res);
+      } else if (req.method === "POST" && path === "/cancel") {
+        handleCancel(req, res);
+      } else if (req.method === "POST" && path === "/plan") {
+        await handlePlan(req, res);
+      } else if (req.method === "POST" && path === "/plan/approve") {
+        await handlePlanApprove(req, res);
+      } else if (req.method === "POST" && path === "/plan/execute") {
+        await handlePlanExecute(req, res);
+      } else if (req.method === "POST" && path === "/plan/review") {
+        await handlePlanReview(req, res);
+      } else if (req.method === "GET" && path.startsWith("/plan/")) {
+        handleGetPlan(path.slice("/plan/".length), res);
+      } else if (req.method === "GET" && path.startsWith("/thread/")) {
+        const threadId = path.slice("/thread/".length);
+        await handleGetThread(threadId, res);
+      } else {
+        sendJson(res, 404, { error: "Not found" });
+      }
+    } catch (err) {
+      console.error("[Bridge] Request error:", err);
+      sendJson(res, 500, {
+        error: err instanceof Error ? err.message : "Internal error"
+      });
+    }
+  });
+  async function handleSend(req, res) {
+    const { screenshot, feedback: feedbackStr, color, provider: providerStr, model: modelStr } = await parseMultipart(req);
+    let feedback;
+    try {
+      feedback = JSON.parse(feedbackStr);
+    } catch (e) {
+      sendJson(res, 400, { error: "Invalid feedback JSON" });
+      return;
+    }
+    const jobId = randomUUID().slice(0, 8);
+    const screenshotPath = join2(tempDir, `screenshot-${jobId}.png`);
+    await writeFile2(screenshotPath, screenshot);
+    const linkedSelectors = feedback.annotations.map((a) => a.linkedSelector).filter((s) => !!s);
+    let threadId;
+    if (linkedSelectors.length > 0) {
+      const existingThread = await threadStore.findContinuationThread(linkedSelectors);
+      if (existingThread) {
+        threadId = existingThread.id;
+        await threadStore.addElementIdentifiers(threadId, linkedSelectors);
+      } else {
+        const newThread = await threadStore.createThread(jobId, linkedSelectors);
+        threadId = newThread.id;
+      }
+    }
+    const annotationIds = feedback.annotations.map((a) => a.id);
+    const job = {
+      id: jobId,
+      status: "queued",
+      screenshotPath,
+      feedback,
+      createdAt: Date.now(),
+      color,
+      threadId,
+      annotationIds,
+      provider: providerStr === "claude" || providerStr === "codex" ? providerStr : void 0,
+      model: modelStr || void 0
+    };
+    if (threadId) {
+      const feedbackSummary = feedback.annotations.map((a) => a.instruction || `[${a.type}]`).join("; ");
+      const feedbackContext = formatFeedbackContext(feedback);
+      await threadStore.appendMessage(threadId, {
+        role: "human",
+        timestamp: Date.now(),
+        jobId,
+        screenshotPath,
+        annotationIds,
+        feedbackSummary,
+        feedbackContext: feedbackContext || void 0
+      });
+    }
+    const position = queue.enqueue(job);
+    sendJson(res, 200, { jobId, position, threadId });
+  }
+  async function handleReply(req, res) {
+    const chunks = [];
+    try {
+      for (var iter = __forAwait(req), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const chunk = temp.value;
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    const body = Buffer.concat(chunks).toString("utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch (e) {
+      sendJson(res, 400, { error: "Invalid JSON" });
+      return;
+    }
+    const { threadId, reply, color, provider: providerStr, model: modelStr } = parsed;
+    if (!threadId || !reply) {
+      sendJson(res, 400, { error: "Missing threadId or reply" });
+      return;
+    }
+    const thread = await threadStore.getThread(threadId);
+    if (!thread) {
+      sendJson(res, 404, { error: "Thread not found" });
+      return;
+    }
+    const jobId = randomUUID().slice(0, 8);
+    let screenshotPath = "";
+    {
+      const history2 = await threadStore.getThreadHistory(threadId);
+      for (let i = history2.length - 1; i >= 0; i--) {
+        if (history2[i].screenshotPath) {
+          screenshotPath = history2[i].screenshotPath;
+          break;
+        }
+      }
+    }
+    if (!screenshotPath) {
+      sendJson(res, 400, { error: "No screenshot available" });
+      return;
+    }
+    await threadStore.appendMessage(threadId, {
+      role: "human",
+      timestamp: Date.now(),
+      jobId,
+      replyToQuestion: reply,
+      screenshotPath
+    });
+    const history = await threadStore.getThreadHistory(threadId);
+    const annotationIds = [];
+    for (const msg of history) {
+      if (msg.annotationIds) {
+        for (const id of msg.annotationIds) {
+          if (!annotationIds.includes(id)) annotationIds.push(id);
+        }
+      }
+    }
+    const replyProvider = providerStr === "claude" || providerStr === "codex" ? providerStr : void 0;
+    const prompt = buildReplyPrompt(screenshotPath, history, replyProvider);
+    const job = {
+      id: jobId,
+      status: "queued",
+      screenshotPath,
+      feedback: { timestamp: (/* @__PURE__ */ new Date()).toISOString(), url: "", viewport: { width: 0, height: 0 }, scrollPosition: { x: 0, y: 0 }, annotations: [], styleModifications: [] },
+      createdAt: Date.now(),
+      color,
+      threadId,
+      annotationIds: annotationIds.length > 0 ? annotationIds : void 0,
+      provider: replyProvider,
+      model: modelStr || void 0
+    };
+    job._replyPrompt = prompt;
+    const position = queue.enqueue(job);
+    sendJson(res, 200, { jobId, position, threadId });
+  }
+  function handleEvents(req, res) {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    res.write(`event: connected
+data: {"status":"connected"}
+
+`);
+    const client = { id: randomUUID().slice(0, 8), res };
+    sseClients.add(client);
+    req.on("close", () => {
+      sseClients.delete(client);
+    });
+  }
+  function handleStatus(res) {
+    const allActive = queue.allActive;
+    sendJson(res, 200, {
+      ok: true,
+      activeJob: allActive[0] ? { id: allActive[0].id, status: allActive[0].status } : null,
+      activeJobs: allActive.map((j) => ({ id: j.id, status: j.status })),
+      queueDepth: queue.depth
+    });
+  }
+  function handleCancel(req, res) {
+    const reqUrl = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+    const jobId = reqUrl.searchParams.get("jobId");
+    const cancelled = jobId ? queue.cancelJob(jobId) : queue.cancelActive();
+    sendJson(res, 200, { cancelled });
+  }
+  async function handlePlan(req, res) {
+    const { screenshot, feedback: feedbackStr, goal: goalStr, pageUrl: pageUrlStr, viewport: viewportStr, provider: providerStr, model: modelStr, manifest: manifestStr } = await parseMultipart(req);
+    if (!screenshot || !goalStr) {
+      sendJson(res, 400, { error: "Missing screenshot or goal" });
+      return;
+    }
+    const pageUrl = pageUrlStr || "";
+    let viewport = { width: 1440, height: 900 };
+    try {
+      if (viewportStr) viewport = JSON.parse(viewportStr);
+    } catch (e) {
+    }
+    let feedbackContext;
+    if (feedbackStr) {
+      try {
+        const feedback = JSON.parse(feedbackStr);
+        const ctx = formatFeedbackContext(feedback);
+        if (ctx) feedbackContext = ctx;
+      } catch (e) {
+      }
+    }
+    const planId = randomUUID().slice(0, 8);
+    const jobId = randomUUID().slice(0, 8);
+    const screenshotPath = join2(tempDir, `screenshot-plan-${planId}.png`);
+    await writeFile2(screenshotPath, screenshot);
+    const thread = await threadStore.createThread(jobId, []);
+    const threadId = thread.id;
+    const group = {
+      id: planId,
+      goal: goalStr,
+      status: "planning",
+      plannerJobId: jobId,
+      plannerThreadId: threadId,
+      workerJobIds: [],
+      screenshotPath,
+      pageUrl,
+      viewport,
+      createdAt: Date.now()
+    };
+    jobGroups.set(planId, group);
+    const prompt = buildPlannerPrompt(screenshotPath, goalStr, pageUrl, viewport, manifestStr, feedbackContext);
+    await threadStore.appendMessage(threadId, {
+      role: "human",
+      timestamp: Date.now(),
+      jobId,
+      screenshotPath,
+      feedbackSummary: `Plan: ${goalStr}`,
+      feedbackContext: `Goal: ${goalStr}
+Page: ${pageUrl}`
+    });
+    const provider = providerStr === "claude" || providerStr === "codex" ? providerStr : defaultProvider;
+    const job = {
+      id: jobId,
+      status: "queued",
+      screenshotPath,
+      feedback: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url: pageUrl,
+        viewport,
+        scrollPosition: { x: 0, y: 0 },
+        annotations: [],
+        styleModifications: []
+      },
+      createdAt: Date.now(),
+      threadId,
+      provider,
+      model: modelStr || void 0,
+      planId
+    };
+    job._replyPrompt = prompt;
+    job._allowedTools = ["Read"];
+    const position = queue.enqueue(job);
+    sendJson(res, 200, { planId, jobId, position, threadId });
+  }
+  async function handlePlanApprove(req, res) {
+    const chunks = [];
+    try {
+      for (var iter = __forAwait(req), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const chunk = temp.value;
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    const body = Buffer.concat(chunks).toString("utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch (e) {
+      sendJson(res, 400, { error: "Invalid JSON" });
+      return;
+    }
+    const { planId, approvedTaskIds } = parsed;
+    if (!planId) {
+      sendJson(res, 400, { error: "Missing planId" });
+      return;
+    }
+    const group = jobGroups.get(planId);
+    if (!group) {
+      sendJson(res, 404, { error: "Plan not found" });
+      return;
+    }
+    if (!group.plan) {
+      sendJson(res, 400, { error: "Plan has no tasks" });
+      return;
+    }
+    const tasks = approvedTaskIds ? group.plan.filter((t) => approvedTaskIds.includes(t.id)) : group.plan;
+    group.status = "executing";
+    sendJson(res, 200, { planId, tasks, status: "executing" });
+  }
+  async function handlePlanExecute(req, res) {
+    const { screenshot, planId: planIdStr, tasks: tasksStr, provider: providerStr, model: modelStr } = await parseMultipart(req);
+    if (!planIdStr || !tasksStr || !screenshot) {
+      sendJson(res, 400, { error: "Missing planId, tasks, or screenshot" });
+      return;
+    }
+    const group = jobGroups.get(planIdStr);
+    if (!group) {
+      sendJson(res, 404, { error: "Plan not found" });
+      return;
+    }
+    if (group.status !== "executing") {
+      sendJson(res, 400, { error: `Plan status is ${group.status}, expected executing` });
+      return;
+    }
+    let tasks;
+    try {
+      tasks = JSON.parse(tasksStr);
+    } catch (e) {
+      sendJson(res, 400, { error: "Invalid tasks JSON" });
+      return;
+    }
+    const jobId = randomUUID().slice(0, 8);
+    const screenshotPath = join2(tempDir, `screenshot-exec-${planIdStr}.png`);
+    await writeFile2(screenshotPath, screenshot);
+    const provider = providerStr === "claude" || providerStr === "codex" ? providerStr : defaultProvider;
+    const prompt = buildPlanExecutorPrompt(screenshotPath, tasks, group.pageUrl, group.viewport, provider);
+    const annotationIds = tasks.map((t) => t.annotationId);
+    const job = {
+      id: jobId,
+      status: "queued",
+      screenshotPath,
+      feedback: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url: group.pageUrl,
+        viewport: group.viewport,
+        scrollPosition: { x: 0, y: 0 },
+        annotations: [],
+        styleModifications: []
+      },
+      createdAt: Date.now(),
+      provider,
+      model: modelStr || void 0,
+      planId: planIdStr,
+      annotationIds
+    };
+    job._replyPrompt = prompt;
+    job._isPlanExecutor = true;
+    group.executorJobId = jobId;
+    const position = queue.enqueue(job);
+    sendJson(res, 200, { jobId, planId: planIdStr, position });
+  }
+  async function handlePlanReview(req, res) {
+    const { screenshot, planId: planIdStr, provider: providerStr, model: modelStr } = await parseMultipart(req);
+    if (!planIdStr) {
+      sendJson(res, 400, { error: "Missing planId" });
+      return;
+    }
+    const group = jobGroups.get(planIdStr);
+    if (!group) {
+      sendJson(res, 404, { error: "Plan not found" });
+      return;
+    }
+    group.status = "reviewing";
+    const jobId = randomUUID().slice(0, 8);
+    let screenshotPath = group.screenshotPath;
+    if (screenshot) {
+      screenshotPath = join2(tempDir, `screenshot-review-${planIdStr}.png`);
+      await writeFile2(screenshotPath, screenshot);
+    }
+    const completedTasks = (group.plan || []).map((t) => ({
+      id: t.id,
+      instruction: t.instruction,
+      summary: "completed"
+      // Workers will have set resolution summaries
+    }));
+    const prompt = buildReviewerPrompt(screenshotPath, group.goal, completedTasks);
+    const provider = providerStr === "claude" || providerStr === "codex" ? providerStr : defaultProvider;
+    const job = {
+      id: jobId,
+      status: "queued",
+      screenshotPath,
+      feedback: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url: group.pageUrl,
+        viewport: group.viewport,
+        scrollPosition: { x: 0, y: 0 },
+        annotations: [],
+        styleModifications: []
+      },
+      createdAt: Date.now(),
+      // Don't set threadId — avoids resuming planner session, which would discard the review prompt
+      provider,
+      model: modelStr || void 0,
+      planId: planIdStr
+    };
+    job._replyPrompt = prompt;
+    job._isReview = true;
+    job._allowedTools = ["Read"];
+    const position = queue.enqueue(job);
+    sendJson(res, 200, { jobId, planId: planIdStr, position });
+  }
+  function handleGetPlan(planId, res) {
+    const group = jobGroups.get(planId);
+    if (!group) {
+      sendJson(res, 404, { error: "Plan not found" });
+      return;
+    }
+    sendJson(res, 200, group);
+  }
+  async function handleGetThread(threadId, res) {
+    const thread = await threadStore.getThread(threadId);
+    if (!thread) {
+      sendJson(res, 404, { error: "Thread not found" });
+      return;
+    }
+    const messages = thread.messages.map((_a2) => {
+      var _b2 = _a2, { screenshotPath } = _b2, rest = __objRest(_b2, ["screenshotPath"]);
+      return rest;
+    });
+    sendJson(res, 200, { id: thread.id, createdAt: thread.createdAt, messages });
+  }
+  const cleanupTimer = setInterval(() => {
+    cleanupTempDir(tempDir).catch(() => {
+    });
+  }, CLEANUP_INTERVAL_MS);
+  return new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.log(`[\u22B9 already watching :${port}]`);
+        resolve({
+          port,
+          close: async () => {
+          }
+        });
+        return;
+      }
+      reject(err);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      console.log(`[\u22B9 is watching :${port}]`);
+      resolve({
+        port,
+        close: async () => {
+          clearInterval(cleanupTimer);
+          queue.destroy();
+          for (const client of sseClients) {
+            try {
+              client.res.end();
+            } catch (e) {
+            }
+          }
+          sseClients.clear();
+          return new Promise((res) => {
+            server.close(() => res());
+          });
+        }
+      });
+    });
+  });
+}
+async function cleanupTempDir(tempDir) {
+  try {
+    const files = await readdir(tempDir);
+    const now = Date.now();
+    for (const file of files) {
+      const filePath = join2(tempDir, file);
+      try {
+        const stats = await stat(filePath);
+        if (now - stats.mtimeMs > MAX_FILE_AGE_MS) {
+          await unlink(filePath);
+        }
+      } catch (e) {
+      }
+    }
+  } catch (e) {
+  }
+}
+
+// src/server/index.ts
+async function startPopmelt(options) {
+  if (process.env.NODE_ENV === "production" && !(options == null ? void 0 : options.force)) {
+    throw new Error(
+      "[Bridge] Refusing to start in production. Pass { force: true } to override."
+    );
+  }
+  return createPopmelt(options);
+}
+export {
+  startPopmelt
+};