vibespot 0.5.2 → 0.7.0

package/dist/index.js

@@ -1096,60 +1096,49 @@ import { join as join6, basename as basename2 } from "path";
 import { readdirSync as readdirSync4, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
 
 // src/ai/prompts.ts
-function getConversionGuide() {
+var guideCache = /* @__PURE__ */ new Map();
+function cachedAsset(name) {
+  let val = guideCache.get(name);
+  if (val !== void 0) return val;
   try {
-    return readFile(resolveAsset("conversion-guide.md"));
+    val = readFile(resolveAsset(name));
   } catch {
-    return "Conversion guide not found. Using built-in rules.";
+    val = "";
   }
+  guideCache.set(name, val);
+  return val;
+}
+function getConversionGuide() {
+  return cachedAsset("conversion-guide.md") || "Conversion guide not found. Using built-in rules.";
 }
 function getDesignGuide() {
-  try {
-    return readFile(resolveAsset("design-guide.md"));
-  } catch {
-    return "";
-  }
+  return cachedAsset("design-guide.md");
 }
 function getContentGuide() {
-  try {
-    return readFile(resolveAsset("content-guide.md"));
-  } catch {
-    return "";
-  }
+  return cachedAsset("content-guide.md");
 }
 function getHubspotRules() {
-  try {
-    return readFile(resolveAsset("hubspot-rules.md"));
-  } catch {
-    return "";
-  }
+  return cachedAsset("hubspot-rules.md");
 }
 function getHumanifyGuide() {
-  try {
-    return readFile(resolveAsset("humanify-guide.md"));
-  } catch {
-    return "";
-  }
+  return cachedAsset("humanify-guide.md");
 }
 function getPageTypeGuide(pageType) {
-  try {
-    const fullGuide = readFile(resolveAsset("page-types.md"));
-    const sectionHeaders = {
-      landing_page: "## Landing Page",
-      blog_post: "## Blog Post",
-      website_page: "## Website Page",
-      module_only: "## Module Only"
-    };
-    const header = sectionHeaders[pageType];
-    if (!header) return "";
-    const startIdx = fullGuide.indexOf(header);
-    if (startIdx < 0) return "";
-    const afterHeader = fullGuide.indexOf("\n## ", startIdx + header.length);
-    const section = afterHeader >= 0 ? fullGuide.slice(startIdx, afterHeader).trim() : fullGuide.slice(startIdx).trim();
-    return section;
-  } catch {
-    return "";
-  }
+  const fullGuide = cachedAsset("page-types.md");
+  if (!fullGuide) return "";
+  const sectionHeaders = {
+    landing_page: "## Landing Page",
+    blog_post: "## Blog Post",
+    website_page: "## Website Page",
+    module_only: "## Module Only"
+  };
+  const header = sectionHeaders[pageType];
+  if (!header) return "";
+  const startIdx = fullGuide.indexOf(header);
+  if (startIdx < 0) return "";
+  const afterHeader = fullGuide.indexOf("\n## ", startIdx + header.length);
+  const section = afterHeader >= 0 ? fullGuide.slice(startIdx, afterHeader).trim() : fullGuide.slice(startIdx).trim();
+  return section;
 }
 function buildSystemPrompt(conversionGuide) {
   return `You are a HubSpot CMS expert converting React/Tailwind pages to native HubSpot modules.
@@ -1654,7 +1643,7 @@ import { join as join7, basename as basename3 } from "path";
 import { readdirSync as readdirSync5 } from "fs";
 var ClaudeAPIEngine = class {
   client;
-  model = "claude-sonnet-4-20250514";
+  model = "claude-sonnet-4-6";
   constructor(apiKey) {
     this.client = new Anthropic({
       apiKey: apiKey || process.env.ANTHROPIC_API_KEY
@@ -3096,15 +3085,15 @@ import chalk2 from "chalk";
 
 // src/server/server.ts
 import { createServer } from "http";
-import { readFileSync as readFileSync5, existsSync as existsSync5, readdirSync as readdirSync11, appendFileSync, rmSync as rmSync5, renameSync as renameSync2 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync5, readdirSync as readdirSync11, appendFileSync, rmSync as rmSync5, renameSync as renameSync3 } from "fs";
 import { join as join15, extname as extname2, basename as basename7 } from "path";
 import { homedir as homedir4 } from "os";
 import { execSync as execSync4 } from "child_process";
 import { WebSocketServer } from "ws";
 
 // src/server/session.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync10, existsSync as existsSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, rmSync as rmSync4 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync4, readdirSync as readdirSync10, existsSync as existsSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, rmSync as rmSync4, renameSync as renameSync2 } from "fs";
+import { join as join14, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/server/project-git.ts
@@ -3158,6 +3147,29 @@ function commitThemeState(themePath, message) {
   const hashResult = run("git rev-parse --short HEAD", { cwd: themePath });
   return hashResult.success ? hashResult.stdout : null;
 }
+function commitTemplateState(themePath, templateId, message, filePaths) {
+  if (!isGitAvailable()) return null;
+  if (!existsSync3(join13(themePath, ".git"))) return null;
+  for (const fp of filePaths) {
+    const fullPath = join13(themePath, fp);
+    if (existsSync3(fullPath)) {
+      run(`git add "${fp}"`, { cwd: themePath });
+    }
+  }
+  const diff = run("git diff --cached --quiet", { cwd: themePath });
+  if (diff.success) return null;
+  const prefix = `[${templateId}] `;
+  const maxMsg = 72 - prefix.length;
+  const truncated = message.length > maxMsg ? message.slice(0, maxMsg - 3) + "..." : message;
+  const fullMessage = prefix + truncated;
+  const commitResult = run(`git commit -m "${fullMessage.replace(/"/g, '\\"')}"`, { cwd: themePath });
+  if (!commitResult.success) {
+    console.warn(`[project-git] template commit failed: ${commitResult.stderr}`);
+    return null;
+  }
+  const hashResult = run("git rev-parse --short HEAD", { cwd: themePath });
+  return hashResult.success ? hashResult.stdout : null;
+}
 function getHistory(themePath, limit = 50) {
   if (!isGitAvailable()) return [];
   if (!existsSync3(join13(themePath, ".git"))) return [];
@@ -3181,6 +3193,30 @@ function getHistory(themePath, limit = 50) {
   }
   return commits;
 }
+function getTemplateHistory(themePath, templateId, limit = 50) {
+  if (!isGitAvailable()) return [];
+  if (!existsSync3(join13(themePath, ".git"))) return [];
+  const escapedId = templateId.replace(/[[\]\\]/g, "\\$&");
+  const result = run(
+    `git log --grep="\\[${escapedId}\\]" --pretty=format:"%h|%H|%s|%at" -n ${limit}`,
+    { cwd: themePath }
+  );
+  if (!result.success || !result.stdout.trim()) return [];
+  const commits = [];
+  for (const line of result.stdout.split("\n")) {
+    const parts = line.split("|");
+    if (parts.length < 4) continue;
+    const timestamp = parseInt(parts[3], 10) * 1e3;
+    commits.push({
+      hash: parts[0],
+      fullHash: parts[1],
+      message: parts[2],
+      timestamp,
+      date: new Date(timestamp).toISOString()
+    });
+  }
+  return commits;
+}
 function rollbackToCommit(themePath, commitHash) {
   if (!isGitAvailable()) return { success: false, error: "Git not available" };
   if (!existsSync3(join13(themePath, ".git"))) return { success: false, error: "Not a git repo" };
@@ -3198,9 +3234,91 @@ function rollbackToCommit(themePath, commitHash) {
   run(`git commit -m "${rollbackMsg.replace(/"/g, '\\"')}"`, { cwd: themePath });
   return { success: true };
 }
+function rollbackTemplateToCommit(themePath, templateId, commitHash, filePaths) {
+  if (!isGitAvailable()) return { success: false, error: "Git not available" };
+  if (!existsSync3(join13(themePath, ".git"))) return { success: false, error: "Not a git repo" };
+  const verify = run(`git cat-file -t ${commitHash}`, { cwd: themePath });
+  if (!verify.success || verify.stdout.trim() !== "commit") {
+    return { success: false, error: `Commit ${commitHash} not found` };
+  }
+  const msgResult = run(`git log --format="%s" -1 ${commitHash}`, { cwd: themePath });
+  const origMessage = msgResult.success ? msgResult.stdout : commitHash;
+  let restored = 0;
+  for (const fp of filePaths) {
+    const checkout = run(`git checkout ${commitHash} -- "${fp}"`, { cwd: themePath });
+    if (checkout.success) restored++;
+  }
+  if (restored === 0) {
+    return { success: false, error: "No files could be restored from that commit" };
+  }
+  run("git add -A", { cwd: themePath });
+  const prefix = `[${templateId}] `;
+  const rollbackMsg = `${prefix}Rollback to: ${origMessage}`.slice(0, 72);
+  run(`git commit -m "${rollbackMsg.replace(/"/g, '\\"')}"`, { cwd: themePath });
+  return { success: true };
+}
 
 // src/server/session.ts
 var SESSIONS_DIR = join14(homedir3(), ".vibespot", "sessions");
+var INDEX_PATH = join14(SESSIONS_DIR, "_index.json");
+function readIndex() {
+  try {
+    if (!existsSync4(INDEX_PATH)) return rebuildIndex();
+    return JSON.parse(readFileSync4(INDEX_PATH, "utf-8"));
+  } catch {
+    return rebuildIndex();
+  }
+}
+function writeIndex(entries) {
+  try {
+    mkdirSync3(SESSIONS_DIR, { recursive: true });
+    writeFileSync4(INDEX_PATH, JSON.stringify(entries), "utf-8");
+  } catch {
+  }
+}
+function rebuildIndex() {
+  if (!existsSync4(SESSIONS_DIR)) return [];
+  const entries = [];
+  for (const f of readdirSync10(SESSIONS_DIR).filter((f2) => f2.endsWith(".json") && f2 !== "_index.json")) {
+    try {
+      const data = JSON.parse(readFileSync4(join14(SESSIONS_DIR, f), "utf-8"));
+      const templates = data.templates || [];
+      entries.push({
+        id: data.id,
+        themeName: data.themeName,
+        updatedAt: data.updatedAt,
+        moduleCount: templates.reduce((n, t) => n + (t.modules?.length || 0), 0),
+        templateCount: templates.length
+      });
+    } catch {
+    }
+  }
+  writeIndex(entries);
+  return entries;
+}
+function upsertIndex(session) {
+  const entries = readIndex();
+  const templates = session.templates || [];
+  const entry = {
+    id: session.id,
+    themeName: session.themeName,
+    updatedAt: session.updatedAt,
+    moduleCount: templates.reduce((n, t) => n + (t.modules?.length || 0), 0),
+    templateCount: templates.length
+  };
+  const idx = entries.findIndex((e) => e.id === session.id);
+  if (idx >= 0) entries[idx] = entry;
+  else entries.push(entry);
+  writeIndex(entries);
+}
+function removeFromIndex(sessionId) {
+  const entries = readIndex().filter((e) => e.id !== sessionId);
+  writeIndex(entries);
+}
+function removeFromIndexByTheme(themeName) {
+  const entries = readIndex().filter((e) => e.themeName !== themeName);
+  writeIndex(entries);
+}
 var activeSession = null;
 function createSession(themePath, themeName) {
   const session = {
@@ -3282,6 +3400,14 @@ function addTemplate(pageType, label) {
   activeSession.updatedAt = Date.now();
   return entry;
 }
+function renameTemplate(templateId, newLabel) {
+  if (!activeSession) return false;
+  const tpl = activeSession.templates.find((t) => t.id === templateId);
+  if (!tpl) return false;
+  tpl.label = newLabel;
+  activeSession.updatedAt = Date.now();
+  return true;
+}
 function removeTemplate(templateId) {
   if (!activeSession) return false;
   const idx = activeSession.templates.findIndex((t) => t.id === templateId);
@@ -3482,6 +3608,7 @@ function saveSession() {
   mkdirSync3(SESSIONS_DIR, { recursive: true });
   const filePath = join14(SESSIONS_DIR, `${activeSession.id}.json`);
   writeFileSync4(filePath, JSON.stringify(activeSession, null, 2), "utf-8");
+  upsertIndex(activeSession);
 }
 function loadSession(sessionId) {
   const filePath = join14(SESSIONS_DIR, sessionId + ".json");
@@ -3499,21 +3626,7 @@ function loadSession(sessionId) {
 }
 function listSessions() {
   if (!existsSync4(SESSIONS_DIR)) return [];
-  return readdirSync10(SESSIONS_DIR).filter((f) => f.endsWith(".json")).map((f) => {
-    try {
-      const data = JSON.parse(readFileSync4(join14(SESSIONS_DIR, f), "utf-8"));
-      const templates = data.templates || [];
-      return {
-        id: data.id,
-        themeName: data.themeName,
-        updatedAt: data.updatedAt,
-        moduleCount: templates.reduce((n, t) => n + (t.modules?.length || 0), 0),
-        templateCount: templates.length
-      };
-    } catch {
-      return null;
-    }
-  }).filter(Boolean);
+  return readIndex();
 }
 function deleteSession(sessionId, deleteFiles = false) {
   const filePath = join14(SESSIONS_DIR, sessionId + ".json");
@@ -3539,7 +3652,7 @@ function deleteSession(sessionId, deleteFiles = false) {
   } catch {
   }
   if (themeName && existsSync4(SESSIONS_DIR)) {
-    for (const f of readdirSync10(SESSIONS_DIR).filter((f2) => f2.endsWith(".json"))) {
+    for (const f of readdirSync10(SESSIONS_DIR).filter((f2) => f2.endsWith(".json") && f2 !== "_index.json")) {
       try {
         const data = JSON.parse(readFileSync4(join14(SESSIONS_DIR, f), "utf-8"));
         if (data.themeName === themeName) {
@@ -3548,11 +3661,79 @@ function deleteSession(sessionId, deleteFiles = false) {
       } catch {
       }
     }
+    removeFromIndexByTheme(themeName);
+  } else {
+    removeFromIndex(sessionId);
   }
   if (activeSession?.id === sessionId) {
     activeSession = null;
   }
 }
+function renameSession(sessionId, newName) {
+  const filePath = join14(SESSIONS_DIR, sessionId + ".json");
+  if (!existsSync4(filePath)) return { ok: false, error: "Session not found" };
+  let session;
+  try {
+    session = JSON.parse(readFileSync4(filePath, "utf-8"));
+  } catch {
+    return { ok: false, error: "Failed to read session" };
+  }
+  const oldName = session.themeName;
+  if (oldName === newName) return { ok: true };
+  const oldPath = session.themePath;
+  const newPath = join14(dirname2(oldPath), newName);
+  if (existsSync4(oldPath)) {
+    if (existsSync4(newPath)) return { ok: false, error: "A project with that name already exists" };
+    try {
+      renameSync2(oldPath, newPath);
+    } catch (err) {
+      return { ok: false, error: `Failed to rename folder: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const cssOld = join14(newPath, "css", `${oldName}-theme.css`);
+    const cssNew = join14(newPath, "css", `${newName}-theme.css`);
+    if (existsSync4(cssOld)) try {
+      renameSync2(cssOld, cssNew);
+    } catch {
+    }
+    const jsOld = join14(newPath, "js", `${oldName}-animations.js`);
+    const jsNew = join14(newPath, "js", `${newName}-animations.js`);
+    if (existsSync4(jsOld)) try {
+      renameSync2(jsOld, jsNew);
+    } catch {
+    }
+    const themeJsonPath = join14(newPath, "theme.json");
+    if (existsSync4(themeJsonPath)) {
+      try {
+        const themeData = JSON.parse(readFileSync4(themeJsonPath, "utf-8"));
+        themeData.label = newName;
+        themeData.name = newName;
+        writeFileSync4(themeJsonPath, JSON.stringify(themeData, null, 2), "utf-8");
+      } catch {
+      }
+    }
+  }
+  if (existsSync4(SESSIONS_DIR)) {
+    for (const f of readdirSync10(SESSIONS_DIR).filter((f2) => f2.endsWith(".json") && f2 !== "_index.json")) {
+      try {
+        const data = JSON.parse(readFileSync4(join14(SESSIONS_DIR, f), "utf-8"));
+        if (data.themeName === oldName) {
+          data.themeName = newName;
+          data.themePath = newPath;
+          data.updatedAt = Date.now();
+          writeFileSync4(join14(SESSIONS_DIR, f), JSON.stringify(data, null, 2), "utf-8");
+        }
+      } catch {
+      }
+    }
+  }
+  if (activeSession && activeSession.themeName === oldName) {
+    activeSession.themeName = newName;
+    activeSession.themePath = newPath;
+    activeSession.updatedAt = Date.now();
+  }
+  rebuildIndex();
+  return { ok: true };
+}
 function writeModulesToDisk() {
   if (!activeSession) return;
   const themePath = activeSession.themePath;
@@ -3663,6 +3844,37 @@ function reloadModulesFromDisk() {
   activeSession.updatedAt = Date.now();
   syncFlatFieldsToTemplate();
 }
+function reloadActiveTemplateFromDisk() {
+  if (!activeSession) return;
+  const tpl = getActiveTemplate();
+  if (!tpl) return;
+  const themePath = activeSession.themePath;
+  const modulesDir = join14(themePath, "modules");
+  tpl.modules = [];
+  for (const name of tpl.moduleOrder) {
+    const modDir = join14(modulesDir, `${name}.module`);
+    if (!existsSync4(modDir)) continue;
+    const mod = {
+      moduleName: name,
+      fieldsJson: safeRead(join14(modDir, "fields.json")),
+      metaJson: safeRead(join14(modDir, "meta.json")),
+      moduleHtml: safeRead(join14(modDir, "module.html")),
+      moduleCss: safeRead(join14(modDir, "module.css")),
+      moduleJs: safeRead(join14(modDir, "module.js")) || void 0
+    };
+    if (mod.fieldsJson && mod.moduleHtml) {
+      tpl.modules.push(mod);
+    }
+  }
+  if (tpl.templateFile) {
+    const tplPath = join14(themePath, tpl.templateFile);
+    if (existsSync4(tplPath)) {
+      tpl.template = safeRead(tplPath);
+    }
+  }
+  syncFlatFieldsFromTemplate(tpl);
+  activeSession.updatedAt = Date.now();
+}
 function patchBaseTemplate() {
   if (!activeSession) return;
   const basePath = join14(activeSession.themePath, "templates", "layouts", "base.html");
@@ -4457,51 +4669,60 @@ ${conversionGuide}`;
 async function handleGenerateStream(userMessage, onChunk, onStatus) {
   const session = getSession();
   if (!session) throw new Error("No active session");
-  const config = loadConfig();
-  const engine = config.aiEngine || detectDefaultEngine();
-  switch (engine) {
-    case "anthropic-api":
-    case "api": {
-      const apiKey = getApiKeyForEngine("anthropic-api", config);
-      if (!apiKey) throw new Error("Anthropic API key not configured. Open Settings to add one.");
-      await streamWithAnthropicAPI(
-        userMessage,
-        apiKey,
-        session.themeName,
-        config.anthropicApiModel || "claude-sonnet-4-20250514",
-        onChunk
-      );
-      break;
-    }
-    case "openai-api": {
-      const apiKey = getApiKeyForEngine("openai-api", config);
-      if (!apiKey) throw new Error("OpenAI API key not configured. Open Settings to add one.");
-      await streamWithOpenAIAPI(
-        userMessage,
-        apiKey,
-        session.themeName,
-        config.openaiApiModel || "gpt-4o",
-        onChunk
-      );
-      break;
-    }
-    case "gemini-api": {
-      const apiKey = getApiKeyForEngine("gemini-api", config);
-      if (!apiKey) throw new Error("Gemini API key not configured. Open Settings to add one.");
-      await streamWithGeminiAPI(userMessage, apiKey, session.themeName, onChunk);
-      break;
+  const capturedSessionId = session.id;
+  generatingSessionId = capturedSessionId;
+  try {
+    const config = loadConfig();
+    const engine = config.aiEngine || detectDefaultEngine();
+    switch (engine) {
+      case "anthropic-api":
+      case "api": {
+        const apiKey = getApiKeyForEngine("anthropic-api", config);
+        if (!apiKey) throw new Error("Anthropic API key not configured. Open Settings to add one.");
+        await streamWithAnthropicAPI(
+          userMessage,
+          apiKey,
+          session.themeName,
+          config.anthropicApiModel || "claude-sonnet-4-6",
+          onChunk,
+          onStatus
+        );
+        break;
+      }
+      case "openai-api": {
+        const apiKey = getApiKeyForEngine("openai-api", config);
+        if (!apiKey) throw new Error("OpenAI API key not configured. Open Settings to add one.");
+        await streamWithOpenAIAPI(
+          userMessage,
+          apiKey,
+          session.themeName,
+          config.openaiApiModel || "gpt-4o",
+          onChunk,
+          onStatus
+        );
+        break;
+      }
+      case "gemini-api": {
+        const apiKey = getApiKeyForEngine("gemini-api", config);
+        if (!apiKey) throw new Error("Gemini API key not configured. Open Settings to add one.");
+        await streamWithGeminiAPI(userMessage, apiKey, session.themeName, onChunk, onStatus);
+        break;
+      }
+      case "claude-code":
+        await generateWithClaudeCode(userMessage, session.themeName, onChunk, onStatus);
+        break;
+      case "gemini-cli":
+        await generateWithCLI("gemini", userMessage, session.themeName, onChunk, onStatus);
+        break;
+      case "codex-cli":
+        await generateWithCLI("codex", userMessage, session.themeName, onChunk, onStatus);
+        break;
+      default:
+        throw new Error(`Unknown AI engine: ${engine}. Open Settings to configure one.`);
     }
-    case "claude-code":
-      await generateWithClaudeCode(userMessage, session.themeName, onChunk, onStatus);
-      break;
-    case "gemini-cli":
-      await generateWithCLI("gemini", userMessage, session.themeName, onChunk, onStatus);
-      break;
-    case "codex-cli":
-      await generateWithCLI("codex", userMessage, session.themeName, onChunk, onStatus);
-      break;
-    default:
-      throw new Error(`Unknown AI engine: ${engine}. Open Settings to configure one.`);
+  } finally {
+    generatingSessionId = null;
+    parseWarningCallback = null;
   }
 }
 function detectDefaultEngine() {
@@ -4607,33 +4828,73 @@ function setParseWarningCallback(cb) {
   parseWarningCallback = cb;
 }
 function finishResponse(fullResponse) {
+  if (generatingSessionId) {
+    const current = getSession();
+    if (!current || current.id !== generatingSessionId) {
+      console.warn("[ai-handler] Session changed during generation \u2014 discarding AI output");
+      return;
+    }
+  }
   addMessage("assistant", fullResponse);
   parseAndApplyModules(fullResponse);
   saveSession();
 }
-async function streamWithAnthropicAPI(userMessage, apiKey, themeName, model, onChunk) {
+var generatingSessionId = null;
+function isGenerating() {
+  return generatingSessionId !== null;
+}
+var RATE_LIMIT_DELAYS = [10, 20, 40, 60, 120];
+async function streamWithAnthropicAPI(userMessage, apiKey, themeName, model, onChunk, onStatus) {
   const client = new Anthropic2({ apiKey });
   const conversionGuide = getConversionGuide();
   const session = getSession();
   const editMode = session.modules.length > 0;
   const messages = buildMessagesWithContext(userMessage);
-  let fullResponse = "";
-  const stream = client.messages.stream({
-    model,
-    max_tokens: 16384,
-    system: buildVibeSystemPrompt(conversionGuide, themeName, editMode, getPromptContext().pageType, getPromptContext().brandAssets),
-    messages
-  });
-  for await (const event of stream) {
-    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-      const text3 = event.delta.text;
-      fullResponse += text3;
-      onChunk(text3);
+  const systemPrompt = buildVibeSystemPrompt(conversionGuide, themeName, editMode, getPromptContext().pageType, getPromptContext().brandAssets);
+  for (let attempt = 0; ; attempt++) {
+    try {
+      let fullResponse = "";
+      let statusIndex = 0;
+      const sendStatus = onStatus || (() => {
+      });
+      sendStatus(CLI_STATUS_MESSAGES[0]);
+      const heartbeat = setInterval(() => {
+        statusIndex++;
+        sendStatus(CLI_STATUS_MESSAGES[Math.min(statusIndex, CLI_STATUS_MESSAGES.length - 1)]);
+      }, 6e3);
+      try {
+        const stream = client.messages.stream({
+          model,
+          max_tokens: 48e3,
+          system: systemPrompt,
+          messages
+        });
+        for await (const event of stream) {
+          if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+            const text3 = event.delta.text;
+            fullResponse += text3;
+            onChunk(text3);
+          }
+        }
+      } finally {
+        clearInterval(heartbeat);
+      }
+      finishResponse(fullResponse);
+      return;
+    } catch (err) {
+      const status = err.status;
+      const errType = err.error?.type;
+      const is429 = status === 429 || errType === "rate_limit_error" || err instanceof Error && err.message.includes("429");
+      if (!is429 || attempt >= RATE_LIMIT_DELAYS.length) throw err;
+      const wait = RATE_LIMIT_DELAYS[attempt];
+      console.warn(`[ai-handler] Rate limited (429), attempt ${attempt + 1}/${RATE_LIMIT_DELAYS.length} \u2014 waiting ${wait}s`);
+      if (onStatus) onStatus(`Rate limited by Anthropic API \u2014 retrying in ${wait}s...`);
+      await new Promise((r) => setTimeout(r, wait * 1e3));
+      if (onStatus) onStatus("Retrying...");
     }
   }
-  finishResponse(fullResponse);
 }
-async function streamWithOpenAIAPI(userMessage, apiKey, themeName, model, onChunk) {
+async function streamWithOpenAIAPI(userMessage, apiKey, themeName, model, onChunk, onStatus) {
   const conversionGuide = getConversionGuide();
   const editMode = getSession().modules.length > 0;
   const messages = buildMessagesWithContext(userMessage);
@@ -4645,7 +4906,7 @@ async function streamWithOpenAIAPI(userMessage, apiKey, themeName, model, onChun
     },
     body: JSON.stringify({
       model,
-      max_tokens: 16384,
+      max_tokens: 48e3,
       stream: true,
       messages: [
         { role: "system", content: buildVibeSystemPrompt(conversionGuide, themeName, editMode, getPromptContext().pageType, getPromptContext().brandAssets) },
@@ -4657,34 +4918,46 @@ async function streamWithOpenAIAPI(userMessage, apiKey, themeName, model, onChun
     const err = await response.text();
     throw new Error(`OpenAI API error (${response.status}): ${err}`);
   }
+  let statusIndex = 0;
+  const sendStatus = onStatus || (() => {
+  });
+  sendStatus(CLI_STATUS_MESSAGES[0]);
+  const heartbeat = setInterval(() => {
+    statusIndex++;
+    sendStatus(CLI_STATUS_MESSAGES[Math.min(statusIndex, CLI_STATUS_MESSAGES.length - 1)]);
+  }, 6e3);
   let fullResponse = "";
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.startsWith("data: ")) continue;
-      const data = line.slice(6).trim();
-      if (data === "[DONE]") break;
-      try {
-        const parsed = JSON.parse(data);
-        const delta = parsed.choices?.[0]?.delta?.content;
-        if (delta) {
-          fullResponse += delta;
-          onChunk(delta);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") break;
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta?.content;
+          if (delta) {
+            fullResponse += delta;
+            onChunk(delta);
+          }
+        } catch {
         }
-      } catch {
       }
     }
+  } finally {
+    clearInterval(heartbeat);
   }
   finishResponse(fullResponse);
 }
-async function streamWithGeminiAPI(userMessage, apiKey, themeName, onChunk) {
+async function streamWithGeminiAPI(userMessage, apiKey, themeName, onChunk, onStatus) {
   const conversionGuide = getConversionGuide();
   const session = getSession();
   const editMode = session.modules.length > 0;
@@ -4701,7 +4974,7 @@ async function streamWithGeminiAPI(userMessage, apiKey, themeName, onChunk) {
 ---
 ${stateContext}` : userMessage;
   contents.push({ role: "user", parts: [{ text: userContent }] });
-  const model = "gemini-2.0-flash";
+  const model = "gemini-2.5-flash";
   const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`;
   const response = await fetch(url, {
     method: "POST",
@@ -4709,36 +4982,48 @@ ${stateContext}` : userMessage;
     body: JSON.stringify({
       systemInstruction: { parts: [{ text: buildVibeSystemPrompt(conversionGuide, themeName, editMode, getPromptContext().pageType, getPromptContext().brandAssets) }] },
       contents,
-      generationConfig: { maxOutputTokens: 16384 }
+      generationConfig: { maxOutputTokens: 48e3 }
     })
   });
   if (!response.ok) {
     const err = await response.text();
     throw new Error(`Gemini API error (${response.status}): ${err}`);
   }
+  let statusIndex = 0;
+  const sendStatus = onStatus || (() => {
+  });
+  sendStatus(CLI_STATUS_MESSAGES[0]);
+  const heartbeat = setInterval(() => {
+    statusIndex++;
+    sendStatus(CLI_STATUS_MESSAGES[Math.min(statusIndex, CLI_STATUS_MESSAGES.length - 1)]);
+  }, 6e3);
   let fullResponse = "";
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.startsWith("data: ")) continue;
-      const data = line.slice(6).trim();
-      try {
-        const parsed = JSON.parse(data);
-        const text3 = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
-        if (text3) {
-          fullResponse += text3;
-          onChunk(text3);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        try {
+          const parsed = JSON.parse(data);
+          const text3 = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text3) {
+            fullResponse += text3;
+            onChunk(text3);
+          }
+        } catch {
         }
-      } catch {
       }
     }
+  } finally {
+    clearInterval(heartbeat);
   }
   finishResponse(fullResponse);
 }
@@ -4883,14 +5168,58 @@ function tryParseJSON(raw) {
   }
   return null;
 }
+function tryRepairTruncatedJSON(raw) {
+  const modulesIdx = raw.indexOf('"modules"');
+  if (modulesIdx === -1) return null;
+  const arrayStart = raw.indexOf("[", modulesIdx);
+  if (arrayStart === -1) return null;
+  let lastCompleteModule = -1;
+  let braceDepth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = arrayStart + 1; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") braceDepth++;
+    if (ch === "}") {
+      braceDepth--;
+      if (braceDepth === 0) {
+        lastCompleteModule = i;
+      }
+    }
+  }
+  if (lastCompleteModule === -1) return null;
+  const upToLastModule = raw.slice(0, lastCompleteModule + 1);
+  const repaired = upToLastModule + "]}";
+  const jsonStr = repaired.trimStart().startsWith("{") ? repaired : "{" + repaired;
+  return tryParseJSON(jsonStr);
+}
 function parseAndApplyModules(response) {
   let modulesApplied = false;
-  const blockPattern = /```vibespot-modules\s*\n([\s\S]*?)```/g;
+  const blockPattern = /```vibespot-modules\s*\n?([\s\S]*?)```/g;
   let match;
   while ((match = blockPattern.exec(response)) !== null) {
     try {
+      console.log("[parse] Found vibespot-modules block, length:", match[1].length);
+      console.log("[parse] Block start:", JSON.stringify(match[1].slice(0, 100)));
+      console.log("[parse] Block end:", JSON.stringify(match[1].slice(-100)));
       const data = tryParseJSON(match[1]);
-      if (!data || typeof data !== "object") throw new Error("Invalid JSON after repair");
+      if (!data || typeof data !== "object") {
+        console.warn("[parse] tryParseJSON returned:", data);
+        throw new Error("Invalid JSON after repair");
+      }
       const obj = data;
       if (obj.modules && Array.isArray(obj.modules)) {
         const modules = obj.modules.map((m) => ({
@@ -4914,8 +5243,9 @@ function parseAndApplyModules(response) {
     }
   }
   if (!modulesApplied) {
-    const jsonPattern = /```(?:json)?\s*\n(\{[\s\S]*?"modules"\s*:\s*\[[\s\S]*?\})\s*```/g;
+    const jsonPattern = /```(?:json)?\s*\n([\s\S]*?)```/g;
     while ((match = jsonPattern.exec(response)) !== null) {
+      if (!match[1].includes('"modules"')) continue;
       try {
         const data = tryParseJSON(match[1]);
         if (!data || typeof data !== "object") throw new Error("Invalid JSON after repair");
@@ -4942,6 +5272,44 @@ function parseAndApplyModules(response) {
     }
   }
   if (!modulesApplied) {
+    const fenceCount = (response.match(/```/g) || []).length;
+    if (fenceCount % 2 !== 0 && response.includes('"modules"')) {
+      console.log("[parse] Detected truncated response (odd fence count), attempting salvage...");
+      const lastFenceIdx = response.lastIndexOf("```");
+      let truncated = response.slice(lastFenceIdx + 3);
+      truncated = truncated.replace(/^[\w-]*\s*\n?/, "");
+      const salvaged = tryRepairTruncatedJSON(truncated);
+      if (salvaged) {
+        const obj = salvaged;
+        if (obj.modules && Array.isArray(obj.modules) && obj.modules.length > 0) {
+          console.log("[parse] Salvaged", obj.modules.length, "modules from truncated response");
+          const modules = obj.modules.map((m) => ({
+            moduleName: String(m.moduleName || ""),
+            fieldsJson: typeof m.fieldsJson === "string" ? m.fieldsJson : JSON.stringify(m.fieldsJson, null, 2),
+            metaJson: typeof m.metaJson === "string" ? m.metaJson : JSON.stringify(m.metaJson, null, 2),
+            moduleHtml: String(m.moduleHtml || ""),
+            moduleCss: String(m.moduleCss || ""),
+            moduleJs: m.moduleJs ? String(m.moduleJs) : void 0
+          }));
+          updateModules({
+            modules,
+            sharedCss: obj.sharedCss !== void 0 ? String(obj.sharedCss) : void 0,
+            sharedJs: obj.sharedJs !== void 0 ? String(obj.sharedJs) : void 0
+          });
+          modulesApplied = true;
+          if (parseWarningCallback) {
+            parseWarningCallback("Response was truncated \u2014 some modules may be incomplete. Try sending your request again for the full set.");
+          }
+        }
+      }
+    }
+  }
+  if (!modulesApplied) {
+    console.log("[parse] No modules applied. Response length:", response.length);
+    console.log("[parse] Contains 'vibespot-modules':", response.includes("vibespot-modules"));
+    console.log(`[parse] Contains '"modules"':`, response.includes('"modules"'));
+    console.log("[parse] Fence count:", (response.match(/```/g) || []).length);
+    console.log("[parse] Response preview:", response.slice(0, 500));
     const hasModuleRef = response.includes("vibespot-modules") || response.includes('"modules"');
     const describesProse = /\bmodule|modul/i.test(response) && (/\bcreated?\b|\berstellt\b|\bgenerat/i.test(response) || /\|.*\|.*\|/m.test(response));
     if (hasModuleRef || describesProse) {
@@ -5255,8 +5623,12 @@ function handleApiRoute(method, path, req, res) {
       if (method === "POST") handleDeleteLocalThemeRoute(req, res);
       else jsonResponse(res, 405, { error: "Method not allowed" });
       break;
+    case "/api/themes/rename":
+      if (method === "POST") handleRenameThemeRoute(req, res);
+      else jsonResponse(res, 405, { error: "Method not allowed" });
+      break;
     case "/api/history":
-      if (method === "GET") handleHistoryRoute(res);
+      if (method === "GET") handleHistoryRoute(req, res);
       else jsonResponse(res, 405, { error: "Method not allowed" });
       break;
     case "/api/rollback":
@@ -5275,6 +5647,10 @@ function handleApiRoute(method, path, req, res) {
       if (method === "POST") handleTemplateActivateRoute(req, res);
       else jsonResponse(res, 405, { error: "Method not allowed" });
       break;
+    case "/api/templates/rename":
+      if (method === "POST") handleTemplateRenameRoute(req, res);
+      else jsonResponse(res, 405, { error: "Method not allowed" });
+      break;
     case "/api/module-library":
       if (method === "GET") handleModuleLibraryRoute(res);
       else jsonResponse(res, 405, { error: "Method not allowed" });
@@ -5282,6 +5658,10 @@ function handleApiRoute(method, path, req, res) {
     case "/api/brand-assets":
       handleBrandAssetsRoute(method, req, res);
       break;
+    case "/api/download-zip":
+      if (method === "GET") handleDownloadZipRoute(res);
+      else jsonResponse(res, 405, { error: "Method not allowed" });
+      break;
     default:
       if (path.startsWith("/api/settings/job/") && method === "GET") {
         handleSettingsJobRoute(path, res);
@@ -5482,6 +5862,10 @@ function handleSetupInfoRoute(res) {
 function handleSetupCreateRoute(req, res) {
   readBody(req, (body) => {
     try {
+      if (isGenerating()) {
+        jsonResponse(res, 409, { error: "Cannot switch projects while AI is generating.", generating: true });
+        return;
+      }
       const { name } = JSON.parse(body);
       if (!name || typeof name !== "string") {
         jsonResponse(res, 400, { error: "Theme name is required" });
@@ -5505,7 +5889,7 @@ function handleSetupCreateRoute(req, res) {
         if (newDir) createdAt = join15(process.cwd(), newDir);
       }
       if (createdAt !== themePath && existsSync5(createdAt)) {
-        renameSync2(createdAt, themePath);
+        renameSync3(createdAt, themePath);
       }
       const tplDir = join15(themePath, "templates");
       if (existsSync5(tplDir)) {
@@ -5528,6 +5912,10 @@ function handleSetupCreateRoute(req, res) {
 function handleSetupFetchRoute(req, res) {
   readBody(req, (body) => {
     try {
+      if (isGenerating()) {
+        jsonResponse(res, 409, { error: "Cannot switch projects while AI is generating.", generating: true });
+        return;
+      }
       const { name } = JSON.parse(body);
       if (!name || typeof name !== "string") {
         jsonResponse(res, 400, { error: "Theme name is required" });
@@ -5558,6 +5946,10 @@ function handleSetupFetchRoute(req, res) {
 function handleSetupOpenRoute(req, res) {
   readBody(req, (body) => {
     try {
+      if (isGenerating()) {
+        jsonResponse(res, 409, { error: "Cannot switch projects while AI is generating.", generating: true });
+        return;
+      }
       const { path: themePath } = JSON.parse(body);
       if (!themePath || typeof themePath !== "string") {
         jsonResponse(res, 400, { error: "Theme path is required" });
@@ -5589,6 +5981,10 @@ function handleSetupOpenRoute(req, res) {
 function handleSetupResumeRoute(req, res) {
   readBody(req, (body) => {
     try {
+      if (isGenerating()) {
+        jsonResponse(res, 409, { error: "Cannot switch projects while AI is generating.", generating: true });
+        return;
+      }
       const { sessionId } = JSON.parse(body);
       if (!sessionId || typeof sessionId !== "string") {
         jsonResponse(res, 400, { error: "Session ID is required" });
@@ -5626,17 +6022,112 @@ function handleSetupApiKeyRoute(req, res) {
     }
   });
 }
+var modelCache = { data: {}, ts: 0 };
+var MODEL_CACHE_TTL = 10 * 60 * 1e3;
+var STATIC_MODELS = {
+  "claude-code": [
+    { id: "sonnet", label: "Claude Sonnet (default)" },
+    { id: "opus", label: "Claude Opus" },
+    { id: "haiku", label: "Claude Haiku" }
+  ],
+  "codex-cli": [
+    { id: "o4-mini", label: "o4 Mini (default)" },
+    { id: "o3", label: "o3" },
+    { id: "gpt-4o", label: "GPT-4o" }
+  ]
+};
+async function fetchAnthropicModels(apiKey) {
+  const resp = await fetch("https://api.anthropic.com/v1/models", {
+    headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+  });
+  if (!resp.ok) return [];
+  const data = await resp.json();
+  return data.data.filter((m) => !m.id.startsWith("claude-3-") && !m.id.startsWith("claude-2")).map((m) => ({ id: m.id, label: m.display_name }));
+}
+async function fetchOpenAIModels(apiKey) {
+  const resp = await fetch("https://api.openai.com/v1/models", {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!resp.ok) return [];
+  const data = await resp.json();
+  const keep = /^(gpt-4o|gpt-4o-mini|o[1-4](-mini)?|o[1-4]-pro)$/;
+  return data.data.filter((m) => keep.test(m.id)).sort((a, b) => a.id.localeCompare(b.id)).map((m) => ({ id: m.id, label: m.id }));
+}
+async function fetchGeminiModels(apiKey) {
+  const resp = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+  );
+  if (!resp.ok) return [];
+  const data = await resp.json();
+  return data.models.filter((m) => m.name.includes("gemini-2")).map((m) => ({ id: m.name.replace("models/", ""), label: m.displayName }));
+}
+async function getModelCatalog() {
+  if (Date.now() - modelCache.ts < MODEL_CACHE_TTL && Object.keys(modelCache.data).length > 0) {
+    return modelCache.data;
+  }
+  const config = loadConfig();
+  const catalog = { ...STATIC_MODELS };
+  const jobs2 = [];
+  const anthropicKey = getApiKeyForEngine("anthropic-api", config);
+  if (anthropicKey) {
+    jobs2.push(
+      fetchAnthropicModels(anthropicKey).then((models) => {
+        if (models.length) catalog["anthropic-api"] = models;
+      }).catch(() => {
+      })
+    );
+  }
+  const openaiKey = getApiKeyForEngine("openai-api", config);
+  if (openaiKey) {
+    jobs2.push(
+      fetchOpenAIModels(openaiKey).then((models) => {
+        if (models.length) catalog["openai-api"] = models;
+      }).catch(() => {
+      })
+    );
+  }
+  const geminiKey = getApiKeyForEngine("gemini-api", config);
+  if (geminiKey) {
+    jobs2.push(
+      fetchGeminiModels(geminiKey).then((models) => {
+        if (models.length) {
+          catalog["gemini-api"] = models;
+          catalog["gemini-cli"] = models;
+        }
+      }).catch(() => {
+      })
+    );
+  }
+  await Promise.all(jobs2);
+  modelCache.data = catalog;
+  modelCache.ts = Date.now();
+  return catalog;
+}
 function handleSettingsStatusRoute(res) {
   const env = detectEnvironment();
   const config = loadConfig();
-  jsonResponse(res, 200, {
-    environment: env,
-    config: {
-      aiEngine: config.aiEngine || null,
-      claudeCodeModel: config.claudeCodeModel || null,
-      anthropicApiModel: config.anthropicApiModel || null,
-      openaiApiModel: config.openaiApiModel || null
-    }
+  getModelCatalog().then((models) => {
+    jsonResponse(res, 200, {
+      environment: env,
+      config: {
+        aiEngine: config.aiEngine || null,
+        claudeCodeModel: config.claudeCodeModel || null,
+        anthropicApiModel: config.anthropicApiModel || null,
+        openaiApiModel: config.openaiApiModel || null
+      },
+      models
+    });
+  }).catch(() => {
+    jsonResponse(res, 200, {
+      environment: env,
+      config: {
+        aiEngine: config.aiEngine || null,
+        claudeCodeModel: config.claudeCodeModel || null,
+        anthropicApiModel: config.anthropicApiModel || null,
+        openaiApiModel: config.openaiApiModel || null
+      },
+      models: STATIC_MODELS
+    });
   });
 }
 function handleSettingsEngineRoute(req, res) {
@@ -6031,7 +6522,31 @@ function handleDeleteLocalThemeRoute(req, res) {
     }
   });
 }
-function handleHistoryRoute(res) {
+function handleRenameThemeRoute(req, res) {
+  readBody(req, (body) => {
+    try {
+      const { sessionId, newName } = JSON.parse(body);
+      if (!sessionId || !newName || typeof newName !== "string") {
+        jsonResponse(res, 400, { error: "sessionId and newName are required" });
+        return;
+      }
+      const sanitized = newName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-|-$/g, "").replace(/-{2,}/g, "-");
+      if (!sanitized) {
+        jsonResponse(res, 400, { error: "Invalid name" });
+        return;
+      }
+      const result = renameSession(sessionId, sanitized);
+      if (result.ok) {
+        jsonResponse(res, 200, { ok: true, newName: sanitized });
+      } else {
+        jsonResponse(res, 400, { error: result.error });
+      }
+    } catch (err) {
+      jsonResponse(res, 500, { error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+}
+function handleHistoryRoute(req, res) {
   const session = getSession();
   if (!session) {
     jsonResponse(res, 404, { error: "No active session" });
@@ -6041,8 +6556,10 @@ function handleHistoryRoute(res) {
     jsonResponse(res, 200, { available: false, commits: [] });
     return;
   }
-  const commits = getHistory(session.themePath, 50);
-  jsonResponse(res, 200, { available: true, commits });
+  const url = new URL(req.url || "/", "http://localhost");
+  const templateId = url.searchParams.get("templateId");
+  const commits = templateId ? getTemplateHistory(session.themePath, templateId, 50) : getHistory(session.themePath, 50);
+  jsonResponse(res, 200, { available: true, commits, filtered: !!templateId });
 }
 function handleRollbackRoute(req, res) {
   readBody(req, (body) => {
@@ -6052,18 +6569,34 @@ function handleRollbackRoute(req, res) {
         jsonResponse(res, 404, { error: "No active session" });
         return;
       }
-      const { hash } = JSON.parse(body);
+      const { hash, templateId } = JSON.parse(body);
       if (!hash || typeof hash !== "string") {
         jsonResponse(res, 400, { error: "Commit hash is required" });
         return;
       }
       addMessage("assistant", `Rolled back to version ${hash.slice(0, 7)}.`);
-      const result = rollbackToCommit(session.themePath, hash);
-      if (!result.success) {
-        jsonResponse(res, 500, { error: result.error || "Rollback failed" });
-        return;
+      if (templateId) {
+        const tpl = session.templates.find((t) => t.id === templateId);
+        if (!tpl) {
+          jsonResponse(res, 404, { error: "Template not found" });
+          return;
+        }
+        const filePaths = tpl.moduleOrder.map((n) => `modules/${n}.module`);
+        if (tpl.templateFile) filePaths.push(tpl.templateFile);
+        const result = rollbackTemplateToCommit(session.themePath, templateId, hash, filePaths);
+        if (!result.success) {
+          jsonResponse(res, 500, { error: result.error || "Rollback failed" });
+          return;
+        }
+        reloadActiveTemplateFromDisk();
+      } else {
+        const result = rollbackToCommit(session.themePath, hash);
+        if (!result.success) {
+          jsonResponse(res, 500, { error: result.error || "Rollback failed" });
+          return;
+        }
+        reloadModulesFromDisk();
       }
-      reloadModulesFromDisk();
       saveSession();
       jsonResponse(res, 200, {
         ok: true,
@@ -6103,6 +6636,41 @@ function handleDashboardRoute(res) {
     }
   });
 }
+function handleDownloadZipRoute(res) {
+  const session = getSession();
+  if (!session) {
+    jsonResponse(res, 404, { error: "No active session" });
+    return;
+  }
+  const themePath = session.themePath;
+  if (!existsSync5(themePath)) {
+    jsonResponse(res, 404, { error: "Theme directory not found" });
+    return;
+  }
+  const themeName = session.themeName || "theme";
+  const parentDir = join15(themePath, "..");
+  const folderName = basename7(themePath);
+  try {
+    const zipFileName = `${themeName}.zip`;
+    const tmpZip = join15(parentDir, zipFileName);
+    if (existsSync5(tmpZip)) rmSync5(tmpZip);
+    execSync4(
+      `zip -r "${zipFileName}" "${folderName}" -x "${folderName}/.git/*" "${folderName}/.vibespot/*" "${folderName}/node_modules/*"`,
+      { cwd: parentDir, timeout: 3e4 }
+    );
+    const zipData = readFileSync5(tmpZip);
+    rmSync5(tmpZip);
+    res.writeHead(200, {
+      "Content-Type": "application/zip",
+      "Content-Disposition": `attachment; filename="${zipFileName}"`,
+      "Content-Length": zipData.length
+    });
+    res.end(zipData);
+  } catch (err) {
+    console.warn("[download-zip] Failed:", err.message);
+    jsonResponse(res, 500, { error: "Failed to create zip archive" });
+  }
+}
 function handleTemplatesRoute(method, req, res) {
   const session = getSession();
   if (!session) {
@@ -6198,6 +6766,26 @@ function handleTemplateActivateRoute(req, res) {
     }
   });
 }
+function handleTemplateRenameRoute(req, res) {
+  readBody(req, (body) => {
+    try {
+      const { templateId, newLabel } = JSON.parse(body);
+      if (!templateId || !newLabel || typeof newLabel !== "string") {
+        jsonResponse(res, 400, { error: "templateId and newLabel are required" });
+        return;
+      }
+      const success = renameTemplate(templateId, newLabel.trim());
+      if (!success) {
+        jsonResponse(res, 404, { error: "Template not found" });
+        return;
+      }
+      saveSession();
+      jsonResponse(res, 200, { ok: true, newLabel: newLabel.trim() });
+    } catch (err) {
+      jsonResponse(res, 500, { error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+}
 function handleModuleLibraryRoute(res) {
   const library = getModuleLibrary();
   jsonResponse(res, 200, {
@@ -6346,7 +6934,17 @@ function handleWsConnection(ws) {
           const currentSession = getSession();
           if (currentSession) {
             writeModulesToDisk();
-            const commitHash = commitThemeState(currentSession.themePath, userMessage);
+            const activeTpl = getActiveTemplate();
+            let commitHash = null;
+            if (activeTpl) {
+              const filePaths = activeTpl.moduleOrder.map((n) => `modules/${n}.module`);
+              if (activeTpl.templateFile) filePaths.push(activeTpl.templateFile);
+              if (activeTpl.sharedCss) filePaths.push(`css/${currentSession.themeName}-theme.css`);
+              if (activeTpl.sharedJs) filePaths.push(`js/${currentSession.themeName}-animations.js`);
+              commitHash = commitTemplateState(currentSession.themePath, activeTpl.id, userMessage, filePaths);
+            } else {
+              commitHash = commitThemeState(currentSession.themePath, userMessage);
+            }
             if (commitHash) {
               ws.send(JSON.stringify({ type: "version_created", hash: commitHash }));
             }
@@ -6491,6 +7089,7 @@ ${errorContext}`;
     const activeTpl = getActiveTemplate();
     ws.send(JSON.stringify({
       type: "init",
+      sessionId: session.id,
       themeName: session.themeName,
       modules: getOrderedModules().map((m) => m.moduleName),
       messageCount: session.messages.length,