zdev 0.2.4 → 0.2.6

package/dist/index.js

@@ -2461,8 +2461,65 @@ Next steps:`);
 }
 
 // src/commands/start.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve4, basename as basename3, join as join3 } from "path";
+
+// src/vite-patch.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+function patchViteAllowedHosts(viteConfigPath, devDomain) {
+  if (!devDomain) {
+    return { patched: false, reason: "no devDomain configured" };
+  }
+  let content;
+  try {
+    content = readFileSync4(viteConfigPath, "utf-8");
+  } catch {
+    return { patched: false, reason: "could not read vite config" };
+  }
+  const domainPattern = `.${devDomain}`;
+  if (content.includes(domainPattern)) {
+    return { patched: false, reason: "domain already present" };
+  }
+  if (/allowedHosts\s*:\s*true/.test(content)) {
+    return { patched: false, reason: "already allows all hosts (true)" };
+  }
+  if (/allowedHosts\s*:\s*["']all["']/.test(content)) {
+    return { patched: false, reason: 'already allows all hosts ("all")' };
+  }
+  const entry = `"${domainPattern}"`;
+  let patched = false;
+  if (/allowedHosts\s*:\s*\[/.test(content)) {
+    content = content.replace(/(allowedHosts\s*:\s*\[)/, `$1${entry}, `);
+    patched = true;
+  } else if (/server\s*:\s*\{/.test(content)) {
+    content = content.replace(/(server\s*:\s*\{)/, `$1
+    allowedHosts: [${entry}],`);
+    patched = true;
+  } else if (/defineConfig\s*\(\s*\{/.test(content)) {
+    content = content.replace(/(defineConfig\s*\(\s*\{)/, `$1
+  server: {
+    allowedHosts: [${entry}],
+  },`);
+    patched = true;
+  } else if (/export\s+default\s*\{/.test(content)) {
+    content = content.replace(/(export\s+default\s*\{)/, `$1
+  server: {
+    allowedHosts: [${entry}],
+  },`);
+    patched = true;
+  }
+  if (!patched) {
+    return { patched: false, reason: "unrecognized config format" };
+  }
+  try {
+    writeFileSync5(viteConfigPath, content);
+  } catch {
+    return { patched: false, reason: "could not write vite config" };
+  }
+  return { patched: true, reason: "added allowedHosts" };
+}
+
+// src/commands/start.ts
 function detectWebDir(worktreePath) {
   const commonDirs = ["web", "frontend", "app", "client", "packages/web", "apps/web"];
   for (const dir of commonDirs) {
@@ -2548,8 +2605,8 @@ async function start(featureName, projectPath = ".", options = {}) {
       const destPath = join3(webPath, pattern);
       if (existsSync5(srcPath) && !existsSync5(destPath)) {
         try {
-          const content = readFileSync4(srcPath);
-          writeFileSync5(destPath, content);
+          const content = readFileSync5(srcPath);
+          writeFileSync6(destPath, content);
           console.log(`   Copied ${pattern}`);
         } catch (e) {
           console.log(`   Could not copy ${pattern}`);
@@ -2604,30 +2661,13 @@ async function start(featureName, projectPath = ".", options = {}) {
   const viteConfigTsPath = join3(webPath, "vite.config.ts");
   const viteConfigJsPath = join3(webPath, "vite.config.js");
   const viteConfigPath = existsSync5(viteConfigTsPath) ? viteConfigTsPath : existsSync5(viteConfigJsPath) ? viteConfigJsPath : null;
-  if (viteConfigPath) {
-    try {
-      let viteConfig = readFileSync4(viteConfigPath, "utf-8");
-      if (!viteConfig.includes("allowedHosts")) {
-        let patched = false;
-        if (viteConfig.includes("server:") || viteConfig.includes("server :")) {
-          viteConfig = viteConfig.replace(/server\s*:\s*\{/, `server: {
-    allowedHosts: true,`);
-          patched = true;
-        } else if (viteConfig.includes("defineConfig({")) {
-          viteConfig = viteConfig.replace(/defineConfig\(\{/, `defineConfig({
-  server: {
-    allowedHosts: true,
-  },`);
-          patched = true;
-        }
-        if (patched) {
-          writeFileSync5(viteConfigPath, viteConfig);
-          console.log(`   Patched ${basename3(viteConfigPath)} for external access`);
-          run("git", ["update-index", "--skip-worktree", basename3(viteConfigPath)], { cwd: webPath });
-        }
-      }
-    } catch (e) {
-      console.log(`   Could not patch vite config (non-critical)`);
+  if (viteConfigPath && config.devDomain) {
+    const result = patchViteAllowedHosts(viteConfigPath, config.devDomain);
+    if (result.patched) {
+      console.log(`   Patched ${basename3(viteConfigPath)}: ${result.reason}`);
+      run("git", ["update-index", "--skip-worktree", basename3(viteConfigPath)], { cwd: webPath });
+    } else {
+      console.log(`   Vite config: ${result.reason}`);
     }
   }
   console.log(`
@@ -2773,8 +2813,10 @@ function getTmuxSessions(pattern) {
   }
   if (!result.success)
     return [];
-  return result.stdout.split(`
-`).filter(Boolean).filter((name) => name.toLowerCase().includes(pattern.toLowerCase()));
+  const sessions = result.stdout.split(`
+`).filter(Boolean);
+  const patternWords = pattern.split("-").filter((w) => w.length > 2);
+  return sessions.filter((name) => patternWords.some((word) => name.toLowerCase().includes(word.toLowerCase())));
 }
 async function list(options = {}) {
   const config = loadConfig();
@@ -2811,7 +2853,15 @@ No active features.
     const frontendRunning = alloc.pids.frontend ? isProcessRunning(alloc.pids.frontend) : false;
     const convexRunning = alloc.pids.convex ? isProcessRunning(alloc.pids.convex) : false;
     const featureSlug = name.toLowerCase().replace(/[^a-z0-9]/g, "-");
-    const tmuxSessions = getTmuxSessions(featureSlug);
+    const projectSlug = alloc.project.toLowerCase().replace(/[^a-z0-9]/g, "-");
+    const featureOnly = alloc.branch.replace("feature/", "").toLowerCase().replace(/[^a-z0-9]/g, "-");
+    let tmuxSessions = getTmuxSessions(featureSlug);
+    if (tmuxSessions.length === 0) {
+      tmuxSessions = getTmuxSessions(projectSlug);
+    }
+    if (tmuxSessions.length === 0 && featureOnly !== projectSlug) {
+      tmuxSessions = getTmuxSessions(featureOnly);
+    }
     const hasTmux = tmuxSessions.length > 0;
     const isRunning = frontendRunning || convexRunning || hasTmux;
     const isFullyRunning = frontendRunning && convexRunning || hasTmux && tmuxSessions.length >= 2;
@@ -3383,11 +3433,11 @@ ${diffStat}
 }
 
 // src/index.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join as join4 } from "path";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync5(join4(__dirname2, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync6(join4(__dirname2, "..", "package.json"), "utf-8"));
 var program2 = new Command;
 program2.name("zdev").description(`\uD83D\uDC02 zdev v${pkg.version} - Multi-agent worktree development environment`).version(pkg.version);
 program2.command("create <name>").description("Create a new TanStack Start project").option("--convex", "Add Convex backend integration").option("--flat", "Flat structure (no monorepo)").action(async (name, options) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zdev",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Multi-agent worktree development environment for cloud dev with preview URLs",
   "type": "module",
   "bin": {

package/src/commands/list.ts

@@ -22,10 +22,14 @@ function getTmuxSessions(pattern: string): string[] {
   
   if (!result.success) return [];
   
-  return result.stdout
-    .split("\n")
-    .filter(Boolean)
-    .filter(name => name.toLowerCase().includes(pattern.toLowerCase()));
+  const sessions = result.stdout.split("\n").filter(Boolean);
+  
+  // Match if session name contains any word from the pattern
+  const patternWords = pattern.split("-").filter(w => w.length > 2);
+  
+  return sessions.filter(name => 
+    patternWords.some(word => name.toLowerCase().includes(word.toLowerCase()))
+  );
 }
 
 export interface ListOptions {
@@ -74,8 +78,18 @@ export async function list(options: ListOptions = {}): Promise<void> {
       : false;
     
     // Check for tmux sessions related to this feature
+    // Try multiple patterns: full name, project name, feature name
     const featureSlug = name.toLowerCase().replace(/[^a-z0-9]/g, "-");
-    const tmuxSessions = getTmuxSessions(featureSlug);
+    const projectSlug = alloc.project.toLowerCase().replace(/[^a-z0-9]/g, "-");
+    const featureOnly = alloc.branch.replace("feature/", "").toLowerCase().replace(/[^a-z0-9]/g, "-");
+    
+    let tmuxSessions = getTmuxSessions(featureSlug);
+    if (tmuxSessions.length === 0) {
+      tmuxSessions = getTmuxSessions(projectSlug);
+    }
+    if (tmuxSessions.length === 0 && featureOnly !== projectSlug) {
+      tmuxSessions = getTmuxSessions(featureOnly);
+    }
     const hasTmux = tmuxSessions.length > 0;
     
     const isRunning = frontendRunning || convexRunning || hasTmux;

package/src/commands/start.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve, basename, join } from "path";
+import { patchViteAllowedHosts } from "../vite-patch.js";
 import {
   isGitRepo,
   getRepoName,
@@ -219,41 +220,14 @@ export async function start(
   const viteConfigPath = existsSync(viteConfigTsPath) ? viteConfigTsPath : 
                          existsSync(viteConfigJsPath) ? viteConfigJsPath : null;
   
-  if (viteConfigPath) {
-    try {
-      let viteConfig = readFileSync(viteConfigPath, "utf-8");
-      
-      // Only patch if allowedHosts not already present
-      if (!viteConfig.includes("allowedHosts")) {
-        let patched = false;
-        
-        // Try to add allowedHosts to existing server block
-        if (viteConfig.includes("server:") || viteConfig.includes("server :")) {
-          // Add allowedHosts inside existing server block
-          viteConfig = viteConfig.replace(
-            /server\s*:\s*\{/,
-            "server: {\n    allowedHosts: true,"
-          );
-          patched = true;
-        } else if (viteConfig.includes("defineConfig({")) {
-          // No server block, add new one
-          viteConfig = viteConfig.replace(
-            /defineConfig\(\{/,
-            "defineConfig({\n  server: {\n    allowedHosts: true,\n  },"
-          );
-          patched = true;
-        }
-        
-        if (patched) {
-          writeFileSync(viteConfigPath, viteConfig);
-          console.log(`   Patched ${basename(viteConfigPath)} for external access`);
-          
-          // Mark file as skip-worktree so it won't be committed
-          run("git", ["update-index", "--skip-worktree", basename(viteConfigPath)], { cwd: webPath });
-        }
-      }
-    } catch (e) {
-      console.log(`   Could not patch vite config (non-critical)`);
+  if (viteConfigPath && config.devDomain) {
+    const result = patchViteAllowedHosts(viteConfigPath, config.devDomain);
+    if (result.patched) {
+      console.log(`   Patched ${basename(viteConfigPath)}: ${result.reason}`);
+      // Mark file as skip-worktree so it won't be committed
+      run("git", ["update-index", "--skip-worktree", basename(viteConfigPath)], { cwd: webPath });
+    } else {
+      console.log(`   Vite config: ${result.reason}`);
     }
   }
 

package/src/vite-patch.test.ts

@@ -0,0 +1,271 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { patchViteAllowedHosts } from "./vite-patch.js";
+import { writeFileSync, readFileSync, mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const DEV_DOMAIN = "dev.web3citadel.com";
+const DOMAIN_PATTERN = ".dev.web3citadel.com";
+
+let tmpDir: string;
+let configPath: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "vite-patch-test-"));
+  configPath = join(tmpDir, "vite.config.ts");
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function writeConfig(content: string): string {
+  writeFileSync(configPath, content);
+  return configPath;
+}
+
+function readConfig(): string {
+  return readFileSync(configPath, "utf-8");
+}
+
+describe("patchViteAllowedHosts", () => {
+  // ── Skip conditions ─────────────────────────────────────────────
+
+  it("skips when devDomain is empty", () => {
+    writeConfig(`export default defineConfig({ plugins: [] })`);
+    const result = patchViteAllowedHosts(configPath, "");
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe("no devDomain configured");
+  });
+
+  it("skips when file cannot be read", () => {
+    const result = patchViteAllowedHosts("/nonexistent/vite.config.ts", DEV_DOMAIN);
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe("could not read vite config");
+  });
+
+  it("skips when domain pattern already present", () => {
+    writeConfig(`
+export default defineConfig({
+  server: {
+    allowedHosts: ["${DOMAIN_PATTERN}"],
+  },
+  plugins: [],
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe("domain already present");
+  });
+
+  it("skips when allowedHosts is true", () => {
+    writeConfig(`
+export default defineConfig({
+  server: {
+    allowedHosts: true,
+  },
+  plugins: [],
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe("already allows all hosts (true)");
+  });
+
+  it('skips when allowedHosts is "all"', () => {
+    writeConfig(`
+export default defineConfig({
+  server: {
+    allowedHosts: "all",
+  },
+  plugins: [],
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe('already allows all hosts ("all")');
+  });
+
+  it("returns unrecognized for non-matching format", () => {
+    writeConfig(`// just a comment, no config object`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe("unrecognized config format");
+  });
+
+  // ── Inline defineConfig ─────────────────────────────────────────
+
+  it("injects server block into inline defineConfig", () => {
+    writeConfig(`import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+
+export default defineConfig({
+  plugins: [react()],
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`server: {`);
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+    expect(output).toContain(`plugins: [react()]`);
+  });
+
+  // ── Variable-assigned defineConfig ──────────────────────────────
+
+  it("injects server block into variable-assigned defineConfig", () => {
+    writeConfig(`import { defineConfig } from 'vite'
+import viteReact from '@vitejs/plugin-react'
+
+const config = defineConfig({
+  plugins: [
+    viteReact(),
+  ],
+})
+
+export default config`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`server: {`);
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+    expect(output).toContain(`export default config`);
+  });
+
+  // ── Plain export default { } ────────────────────────────────────
+
+  it("injects server block into plain export default object", () => {
+    writeConfig(`export default {
+  plugins: [],
+}`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`server: {`);
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+  });
+
+  // ── Existing server block, no allowedHosts ──────────────────────
+
+  it("merges allowedHosts into existing server block", () => {
+    writeConfig(`export default defineConfig({
+  server: {
+    port: 3000,
+    host: "0.0.0.0",
+  },
+  plugins: [],
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+    expect(output).toContain(`port: 3000`);
+    expect(output).toContain(`host: "0.0.0.0"`);
+  });
+
+  // ── Existing allowedHosts array, different domain ───────────────
+
+  it("appends domain to existing allowedHosts array", () => {
+    writeConfig(`export default defineConfig({
+  server: {
+    allowedHosts: ["other.example.com"],
+  },
+  plugins: [],
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`"${DOMAIN_PATTERN}"`);
+    expect(output).toContain(`"other.example.com"`);
+  });
+
+  // ── Real-world configs from Workstellar repos ───────────────────
+
+  it("patches nft-indexer-provisioner style config", () => {
+    writeConfig(`import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+import tailwindcss from "@tailwindcss/vite"
+import { resolve } from "path"
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "./src"),
+    },
+  },
+})`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`server: {`);
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+    // Preserve existing content
+    expect(output).toContain(`plugins: [react(), tailwindcss()]`);
+    expect(output).toContain(`resolve:`);
+  });
+
+  it("patches clean-it-platform style config (variable assignment)", () => {
+    writeConfig(`import { defineConfig } from 'vite'
+import { tanstackStart } from '@tanstack/react-start/plugin/vite'
+import viteReact from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+const config = defineConfig({
+  plugins: [
+    tailwindcss(),
+    tanstackStart(),
+    viteReact(),
+  ],
+})
+
+export default config`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`server: {`);
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+    expect(output).toContain(`export default config`);
+  });
+
+  it("skips nft-marketplace style config (already has allowedHosts: true)", () => {
+    writeConfig(`import { defineConfig } from 'vite'
+import viteReact from '@vitejs/plugin-react'
+
+const config = defineConfig({
+  server: {
+    allowedHosts: true,
+  },
+  plugins: [
+    viteReact(),
+  ],
+})
+
+export default config`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(false);
+    expect(result.reason).toBe("already allows all hosts (true)");
+  });
+
+  it("patches degen-safe style config (variable, no server block, extra options)", () => {
+    writeConfig(`import { defineConfig } from 'vite'
+import viteReact from '@vitejs/plugin-react'
+
+const config = defineConfig({
+  plugins: [
+    viteReact(),
+  ],
+  optimizeDeps: {
+    include: ['@raydium-io/raydium-sdk-v2'],
+  },
+  ssr: {
+    external: ['lodash'],
+  },
+})
+
+export default config`);
+    const result = patchViteAllowedHosts(configPath, DEV_DOMAIN);
+    expect(result.patched).toBe(true);
+    const output = readConfig();
+    expect(output).toContain(`server: {`);
+    expect(output).toContain(`allowedHosts: ["${DOMAIN_PATTERN}"]`);
+    expect(output).toContain(`optimizeDeps:`);
+    expect(output).toContain(`ssr:`);
+  });
+});

package/src/vite-patch.ts

@@ -0,0 +1,100 @@
+import { readFileSync, writeFileSync } from "fs";
+
+export interface PatchResult {
+  patched: boolean;
+  reason: string;
+}
+
+/**
+ * Patch a Vite config file to include `server.allowedHosts` with the given devDomain.
+ *
+ * Handles these real-world patterns:
+ *   1. `export default defineConfig({ ... })`
+ *   2. `const config = defineConfig({ ... }); export default config`
+ *   3. `export default { ... }` (plain object, no defineConfig)
+ *   4. Existing `server:` block — merges allowedHosts into it
+ *   5. Existing `allowedHosts` array — appends domain if missing
+ *
+ * Skip conditions:
+ *   - File already contains the domain pattern string
+ *   - `allowedHosts` is set to `true` or `"all"` (already permissive)
+ *   - devDomain is empty
+ */
+export function patchViteAllowedHosts(
+  viteConfigPath: string,
+  devDomain: string
+): PatchResult {
+  if (!devDomain) {
+    return { patched: false, reason: "no devDomain configured" };
+  }
+
+  let content: string;
+  try {
+    content = readFileSync(viteConfigPath, "utf-8");
+  } catch {
+    return { patched: false, reason: "could not read vite config" };
+  }
+
+  const domainPattern = `.${devDomain}`;
+
+  // Skip if domain pattern already present in the file
+  if (content.includes(domainPattern)) {
+    return { patched: false, reason: "domain already present" };
+  }
+
+  // Skip if allowedHosts is already set to a permissive value
+  if (/allowedHosts\s*:\s*true/.test(content)) {
+    return { patched: false, reason: "already allows all hosts (true)" };
+  }
+  if (/allowedHosts\s*:\s*["']all["']/.test(content)) {
+    return { patched: false, reason: 'already allows all hosts ("all")' };
+  }
+
+  const entry = `"${domainPattern}"`;
+  let patched = false;
+
+  // Case 1: Existing allowedHosts array — append our domain
+  if (/allowedHosts\s*:\s*\[/.test(content)) {
+    content = content.replace(
+      /(allowedHosts\s*:\s*\[)/,
+      `$1${entry}, `
+    );
+    patched = true;
+  }
+  // Case 2: Existing server block without allowedHosts — inject allowedHosts
+  else if (/server\s*:\s*\{/.test(content)) {
+    content = content.replace(
+      /(server\s*:\s*\{)/,
+      `$1\n    allowedHosts: [${entry}],`
+    );
+    patched = true;
+  }
+  // Case 3: defineConfig({ — add server block
+  else if (/defineConfig\s*\(\s*\{/.test(content)) {
+    content = content.replace(
+      /(defineConfig\s*\(\s*\{)/,
+      `$1\n  server: {\n    allowedHosts: [${entry}],\n  },`
+    );
+    patched = true;
+  }
+  // Case 4: export default { — add server block
+  else if (/export\s+default\s*\{/.test(content)) {
+    content = content.replace(
+      /(export\s+default\s*\{)/,
+      `$1\n  server: {\n    allowedHosts: [${entry}],\n  },`
+    );
+    patched = true;
+  }
+
+  if (!patched) {
+    return { patched: false, reason: "unrecognized config format" };
+  }
+
+  try {
+    writeFileSync(viteConfigPath, content);
+  } catch {
+    return { patched: false, reason: "could not write vite config" };
+  }
+
+  return { patched: true, reason: "added allowedHosts" };
+}