claudekit-cli 3.35.0-dev.29 → 3.35.0-dev.30

package/dist/index.js

@@ -50489,10 +50489,16 @@ function parseBooleanLike(input) {
     if (normalized === "") {
       return { ok: true, value: undefined };
     }
-    if (normalized === "true" || normalized === "1") {
+    if (normalized === "true") {
       return { ok: true, value: true };
     }
-    if (normalized === "false" || normalized === "0") {
+    if (normalized === "false") {
+      return { ok: true, value: false };
+    }
+    if (normalized === "1") {
+      return { ok: true, value: true };
+    }
+    if (normalized === "0") {
       return { ok: true, value: false };
     }
   }
@@ -50533,9 +50539,6 @@ function parseProvidersFromTokens(rawTokens, requiredMessage, maxCountMessage) {
   if (normalizedTokens.length === 0) {
     return { ok: false, error: requiredMessage };
   }
-  if (normalizedTokens.length > MAX_PROVIDER_COUNT) {
-    return { ok: false, error: maxCountMessage };
-  }
   const selectedProviders = [];
   const seen = new Set;
   for (const rawProvider of normalizedTokens) {
@@ -50548,6 +50551,9 @@ function parseProvidersFromTokens(rawTokens, requiredMessage, maxCountMessage) {
       selectedProviders.push(parsed.data);
     }
   }
+  if (selectedProviders.length > MAX_PROVIDER_COUNT) {
+    return { ok: false, error: maxCountMessage };
+  }
   return { ok: true, value: selectedProviders };
 }
 function parseProvidersFromQuery(value) {
@@ -50608,6 +50614,9 @@ function parseConfigSource(input) {
   };
 }
 function getConflictKey(action) {
+  return JSON.stringify([action.provider, action.type, action.item, action.global]);
+}
+function getLegacyConflictKey(action) {
   return `${action.provider}:${action.type}:${action.item}:${action.global}`;
 }
 function validatePlanParity(plan) {
@@ -50688,6 +50697,211 @@ async function executePlanDeleteAction(action, options2) {
 function countEnabledTypes(include) {
   return MIGRATION_TYPES.filter((type) => include[type]).length;
 }
+function inferIncludeFromActions(actions) {
+  const include = {
+    agents: false,
+    commands: false,
+    skills: false,
+    config: false,
+    rules: false
+  };
+  for (const action of actions) {
+    if (action.type === "agent")
+      include.agents = true;
+    else if (action.type === "command")
+      include.commands = true;
+    else if (action.type === "skill")
+      include.skills = true;
+    else if (action.type === "config")
+      include.config = true;
+    else if (action.type === "rules")
+      include.rules = true;
+  }
+  return include;
+}
+function getPlanMeta(plan) {
+  const rawMeta = plan.meta;
+  if (!rawMeta || typeof rawMeta !== "object")
+    return null;
+  return rawMeta;
+}
+function getIncludeFromPlan(plan) {
+  const meta = getPlanMeta(plan);
+  const hasMetaInclude = meta?.include !== undefined;
+  if (meta?.include && typeof meta.include === "object") {
+    const parsed = meta.include;
+    const include = {
+      agents: parsed.agents === true,
+      commands: parsed.commands === true,
+      skills: parsed.skills === true,
+      config: parsed.config === true,
+      rules: parsed.rules === true
+    };
+    if (countEnabledTypes(include) > 0) {
+      return include;
+    }
+  }
+  const inferred = inferIncludeFromActions(plan.actions);
+  if (!hasMetaInclude) {
+    if (countEnabledTypes(inferred) === 0) {
+      return normalizeIncludeOptions(undefined);
+    }
+    return { ...inferred, skills: true };
+  }
+  return inferred;
+}
+function getProvidersFromPlan(plan) {
+  const meta = getPlanMeta(plan);
+  const metaProviders = parseProvidersFromBody(meta?.providers);
+  if (metaProviders.ok && metaProviders.value) {
+    return metaProviders.value;
+  }
+  const providersFromActions = [];
+  const seen = new Set;
+  for (const action of plan.actions) {
+    const parsed = ProviderType.safeParse(action.provider);
+    if (!parsed.success)
+      continue;
+    if (seen.has(parsed.data))
+      continue;
+    seen.add(parsed.data);
+    providersFromActions.push(parsed.data);
+  }
+  return providersFromActions;
+}
+function getConfigSourceFromPlan(plan) {
+  const meta = getPlanMeta(plan);
+  if (typeof meta?.source !== "string") {
+    return;
+  }
+  const parsed = parseConfigSource(meta.source);
+  return parsed.ok ? parsed.value : undefined;
+}
+function getPlanItemsByType(plan, type) {
+  const meta = getPlanMeta(plan);
+  if (!meta?.items || typeof meta.items !== "object")
+    return [];
+  const list = meta.items[type];
+  if (!Array.isArray(list))
+    return [];
+  const normalized = list.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return Array.from(new Set(normalized));
+}
+function providerSupportsType(provider, type) {
+  if (type === "agent")
+    return getProvidersSupporting("agents").includes(provider);
+  if (type === "command")
+    return getProvidersSupporting("commands").includes(provider);
+  if (type === "skill")
+    return getProvidersSupporting("skills").includes(provider);
+  if (type === "config")
+    return getProvidersSupporting("config").includes(provider);
+  return getProvidersSupporting("rules").includes(provider);
+}
+function createSkippedActionResult(action, reason) {
+  const provider = action.provider;
+  return {
+    provider,
+    providerDisplayName: providers[provider]?.displayName || action.provider,
+    success: true,
+    path: action.targetPath,
+    skipped: true,
+    skipReason: reason,
+    portableType: action.type,
+    itemName: action.item
+  };
+}
+function toDiscoveryCounts(results) {
+  const sets = {
+    agents: new Set,
+    commands: new Set,
+    skills: new Set,
+    config: new Set,
+    rules: new Set
+  };
+  for (const result of results) {
+    const itemKey = result.itemName || result.path || `${result.provider}`;
+    if (result.portableType === "agent")
+      sets.agents.add(itemKey);
+    else if (result.portableType === "command")
+      sets.commands.add(itemKey);
+    else if (result.portableType === "skill")
+      sets.skills.add(itemKey);
+    else if (result.portableType === "config")
+      sets.config.add(itemKey);
+    else if (result.portableType === "rules")
+      sets.rules.add(itemKey);
+  }
+  return {
+    agents: sets.agents.size,
+    commands: sets.commands.size,
+    skills: sets.skills.size,
+    config: sets.config.size,
+    rules: sets.rules.size
+  };
+}
+function toExecutionCounts(results) {
+  let installed = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const result of results) {
+    if (!result.success) {
+      failed += 1;
+      continue;
+    }
+    if (result.skipped) {
+      skipped += 1;
+      continue;
+    }
+    installed += 1;
+  }
+  return { installed, skipped, failed };
+}
+function compareSortValues(a3, b3) {
+  if (a3 === b3)
+    return 0;
+  return a3 < b3 ? -1 : 1;
+}
+function sortPortableInstallResults(results) {
+  return [...results].sort((left, right) => {
+    const byType = compareSortValues(left.portableType || "", right.portableType || "");
+    if (byType !== 0)
+      return byType;
+    const byItem = compareSortValues(left.itemName || "", right.itemName || "");
+    if (byItem !== 0)
+      return byItem;
+    const byProvider = compareSortValues(left.provider || "", right.provider || "");
+    if (byProvider !== 0)
+      return byProvider;
+    const byPath = compareSortValues(left.path || "", right.path || "");
+    if (byPath !== 0)
+      return byPath;
+    const leftSuccessRank = left.success ? 0 : 1;
+    const rightSuccessRank = right.success ? 0 : 1;
+    if (leftSuccessRank !== rightSuccessRank) {
+      return leftSuccessRank - rightSuccessRank;
+    }
+    const leftSkippedRank = left.skipped ? 1 : 0;
+    const rightSkippedRank = right.skipped ? 1 : 0;
+    if (leftSkippedRank !== rightSkippedRank) {
+      return leftSkippedRank - rightSkippedRank;
+    }
+    return compareSortValues(left.error || "", right.error || "");
+  });
+}
+function tagResults(results, portableType, itemName) {
+  const singularType = PLURAL_TO_SINGULAR[portableType];
+  for (const result of results) {
+    result.portableType = singularType;
+    if (itemName) {
+      result.itemName = itemName;
+    } else {
+      const pathSegments = result.path.replace(/\\/g, "/").split("/");
+      const lastSegment = pathSegments[pathSegments.length - 1] || "";
+      result.itemName = lastSegment.replace(/\.[^.]+$/, "") || lastSegment;
+    }
+  }
+}
 async function discoverMigrationItems(include, configSource) {
   const agentsSource = include.agents ? getAgentSourcePath() : null;
   const commandsSource = include.commands ? getCommandSourcePath() : null;
@@ -50939,11 +51153,26 @@ function registerMigrationRoutes(app) {
         providerConfigs
       };
       const plan = reconcile(input);
-      res.status(200).json({ plan });
+      const planWithMeta = {
+        ...plan,
+        meta: {
+          include,
+          providers: selectedProviders,
+          source: configSource,
+          items: {
+            agents: discovered.agents.map((item) => item.name),
+            commands: discovered.commands.map((item) => item.name),
+            skills: discovered.skills.map((item) => item.name),
+            config: discovered.configItem ? [discovered.configItem.name] : [],
+            rules: discovered.ruleItems.map((item) => item.name)
+          }
+        }
+      };
+      res.status(200).json({ plan: planWithMeta });
     } catch (error) {
       res.status(500).json({
         error: "Failed to compute reconcile plan",
-        message: error instanceof Error ? error.message : "Unknown error"
+        message: sanitizeUntrusted(error, 260)
       });
     }
   });
@@ -50969,7 +51198,8 @@ function registerMigrationRoutes(app) {
         for (const action of plan.actions) {
           if (action.action === "conflict") {
             const key = getConflictKey(action);
-            const resolution = resolutionsMap.get(key);
+            const legacyKey = getLegacyConflictKey(action);
+            const resolution = resolutionsMap.get(key) || resolutionsMap.get(legacyKey);
             if (!resolution) {
               res.status(409).json({
                 error: `Unresolved conflict: ${action.provider}/${action.type}/${action.item}`
@@ -50988,14 +51218,9 @@ function registerMigrationRoutes(app) {
         }
         const execActions = plan.actions.filter(shouldExecuteAction);
         const deleteActions = plan.actions.filter((a3) => a3.action === "delete");
-        const includeAll = {
-          agents: true,
-          commands: true,
-          skills: true,
-          config: true,
-          rules: true
-        };
-        const discovered2 = await discoverMigrationItems(includeAll);
+        const includeFromPlan = getIncludeFromPlan(plan);
+        const configSourceFromPlan = getConfigSourceFromPlan(plan);
+        const discovered2 = await discoverMigrationItems(includeFromPlan, configSourceFromPlan);
         const agentByName = new Map(discovered2.agents.map((item) => [item.name, item]));
         const commandByName = new Map(discovered2.commands.map((item) => [item.name, item]));
         const skillByName = new Map(discovered2.skills.map((item) => [item.name, item]));
@@ -51005,57 +51230,91 @@ function registerMigrationRoutes(app) {
         for (const action of execActions) {
           const provider = action.provider;
           const installOpts = { global: action.global };
+          const actionType = action.type;
+          if (!providerSupportsType(provider, actionType)) {
+            allResults.push(createSkippedActionResult(action, `Provider ${provider} does not support ${action.type}`));
+            continue;
+          }
           if (action.type === "agent") {
             const item = agentByName.get(action.item);
-            if (!item || !getProvidersSupporting("agents").includes(provider))
+            if (!item) {
+              allResults.push(createSkippedActionResult(action, `Source agent "${action.item}" not found`));
               continue;
-            allResults.push(...await installPortableItems([item], [provider], "agent", installOpts));
+            }
+            const batch = await installPortableItems([item], [provider], "agent", installOpts);
+            tagResults(batch, "agents", action.item);
+            allResults.push(...batch);
           } else if (action.type === "command") {
             const item = commandByName.get(action.item);
-            if (!item || !getProvidersSupporting("commands").includes(provider))
+            if (!item) {
+              allResults.push(createSkippedActionResult(action, `Source command "${action.item}" not found`));
               continue;
-            allResults.push(...await installPortableItems([item], [provider], "command", installOpts));
+            }
+            const batch = await installPortableItems([item], [provider], "command", installOpts);
+            tagResults(batch, "commands", action.item);
+            allResults.push(...batch);
           } else if (action.type === "skill") {
             const item = skillByName.get(action.item);
-            if (!item || !getProvidersSupporting("skills").includes(provider))
+            if (!item) {
+              allResults.push(createSkippedActionResult(action, `Source skill "${action.item}" not found`));
               continue;
-            allResults.push(...await installSkillDirectories([item], [provider], installOpts));
+            }
+            const batch = await installSkillDirectories([item], [provider], installOpts);
+            tagResults(batch, "skills", action.item);
+            allResults.push(...batch);
           } else if (action.type === "config") {
             const item = configByName.get(action.item);
-            if (!item || !getProvidersSupporting("config").includes(provider))
+            if (!item) {
+              allResults.push(createSkippedActionResult(action, `Source config "${action.item}" not found`));
               continue;
-            allResults.push(...await installPortableItems([item], [provider], "config", installOpts));
+            }
+            const batch = await installPortableItems([item], [provider], "config", installOpts);
+            tagResults(batch, "config", action.item);
+            allResults.push(...batch);
           } else if (action.type === "rules") {
             const item = ruleByName.get(action.item);
-            if (!item || !getProvidersSupporting("rules").includes(provider))
+            if (!item) {
+              allResults.push(createSkippedActionResult(action, `Source rule "${action.item}" not found`));
               continue;
-            allResults.push(...await installPortableItems([item], [provider], "rules", installOpts));
+            }
+            const batch = await installPortableItems([item], [provider], "rules", installOpts);
+            tagResults(batch, "rules", action.item);
+            allResults.push(...batch);
           }
         }
         const plannedSkillActions = execActions.filter((a3) => a3.type === "skill").length;
-        if (discovered2.skills.length > 0 && plannedSkillActions === 0) {
-          const planProviders = [
-            ...new Set(plan.actions.map((a3) => a3.provider))
-          ];
-          const skillProviders = planProviders.filter((pv) => getProvidersSupporting("skills").includes(pv));
+        if (includeFromPlan.skills && discovered2.skills.length > 0 && plannedSkillActions === 0) {
+          const allowedSkillNames = getPlanItemsByType(plan, "skills");
+          const plannedSkills = allowedSkillNames.length > 0 ? discovered2.skills.filter((skill) => allowedSkillNames.includes(skill.name)) : discovered2.skills;
+          const planProviders = getProvidersFromPlan(plan);
+          const skillProviders = planProviders.filter((provider) => providerSupportsType(provider, "skill"));
           if (skillProviders.length > 0) {
             const globalFromPlan = plan.actions[0]?.global ?? false;
-            allResults.push(...await installSkillDirectories(discovered2.skills, skillProviders, {
-              global: globalFromPlan
-            }));
+            for (const skill of plannedSkills) {
+              const batch = await installSkillDirectories([skill], skillProviders, {
+                global: globalFromPlan
+              });
+              tagResults(batch, "skills", skill.name);
+              allResults.push(...batch);
+            }
           }
         }
         const writtenPaths = new Set(allResults.filter((r2) => r2.success && !r2.skipped && r2.path.length > 0).map((r2) => resolve8(r2.path)));
         for (const deleteAction of deleteActions) {
-          allResults.push(await executePlanDeleteAction(deleteAction, { preservePaths: writtenPaths }));
+          const deleteResult = await executePlanDeleteAction(deleteAction, {
+            preservePaths: writtenPaths
+          });
+          deleteResult.portableType = deleteAction.type;
+          deleteResult.itemName = deleteAction.item;
+          allResults.push(deleteResult);
         }
-        const installed2 = allResults.filter((r2) => r2.success && !r2.skipped).length;
-        const skipped2 = allResults.filter((r2) => r2.skipped).length;
-        const failed2 = allResults.filter((r2) => !r2.success).length;
+        const sortedResults2 = sortPortableInstallResults(allResults);
+        const counts2 = toExecutionCounts(sortedResults2);
         res.status(200).json({
-          results: allResults,
+          results: sortedResults2,
           warnings: [],
-          counts: { installed: installed2, skipped: skipped2, failed: failed2 }
+          counts: counts2,
+          discovery: toDiscoveryCounts(sortedResults2)
         });
         return;
       }
@@ -51126,59 +51385,82 @@ function registerMigrationRoutes(app) {
       if (include.agents && discovered.agents.length > 0) {
         const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("agents").includes(provider));
         if (providersForType.length > 0) {
-          results.push(...await installPortableItems(discovered.agents, providersForType, "agent", installOptions));
+          const batches = await Promise.all(discovered.agents.map(async (agent) => {
+            const batch = await installPortableItems([agent], providersForType, "agent", installOptions);
+            tagResults(batch, "agents", agent.name);
+            return batch;
+          }));
+          for (const batch of batches) {
+            results.push(...batch);
+          }
         }
       }
       if (include.commands && discovered.commands.length > 0) {
         const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("commands").includes(provider));
         if (providersForType.length > 0) {
-          results.push(...await installPortableItems(discovered.commands, providersForType, "command", installOptions));
+          const batches = await Promise.all(discovered.commands.map(async (command) => {
+            const batch = await installPortableItems([command], providersForType, "command", installOptions);
+            tagResults(batch, "commands", command.name);
+            return batch;
+          }));
+          for (const batch of batches) {
+            results.push(...batch);
+          }
         }
       }
       if (include.skills && discovered.skills.length > 0) {
         const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("skills").includes(provider));
         if (providersForType.length > 0) {
-          results.push(...await installSkillDirectories(discovered.skills, providersForType, installOptions));
+          const batches = await Promise.all(discovered.skills.map(async (skill) => {
+            const batch = await installSkillDirectories([skill], providersForType, installOptions);
+            tagResults(batch, "skills", skill.name);
+            return batch;
+          }));
+          for (const batch of batches) {
+            results.push(...batch);
+          }
         }
       }
       if (include.config && discovered.configItem) {
         const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("config").includes(provider));
         if (providersForType.length > 0) {
-          results.push(...await installPortableItems([discovered.configItem], providersForType, "config", installOptions));
+          const batch = await installPortableItems([discovered.configItem], providersForType, "config", installOptions);
+          tagResults(batch, "config");
+          results.push(...batch);
         }
       }
       if (include.rules && discovered.ruleItems.length > 0) {
         const providersForType = selectedProviders.filter((provider) => getProvidersSupporting("rules").includes(provider));
         if (providersForType.length > 0) {
-          results.push(...await installPortableItems(discovered.ruleItems, providersForType, "rules", installOptions));
+          const batches = await Promise.all(discovered.ruleItems.map(async (rule) => {
+            const batch = await installPortableItems([rule], providersForType, "rules", installOptions);
+            tagResults(batch, "rules", rule.name);
+            return batch;
+          }));
+          for (const batch of batches) {
+            results.push(...batch);
+          }
         }
       }
-      const installed = results.filter((item) => item.success && !item.skipped).length;
-      const skipped = results.filter((item) => item.skipped).length;
-      const failed = results.filter((item) => !item.success).length;
+      const sortedResults = sortPortableInstallResults(results);
+      const counts = toExecutionCounts(sortedResults);
       res.status(200).json({
-        results,
+        results: sortedResults,
         warnings,
         effectiveGlobal,
-        counts: { installed, skipped, failed },
-        discovery: {
-          agents: discovered.agents.length,
-          commands: discovered.commands.length,
-          skills: discovered.skills.length,
-          config: discovered.configItem ? 1 : 0,
-          rules: discovered.ruleItems.length
-        },
+        counts,
+        discovery: toDiscoveryCounts(sortedResults),
         unsupportedByType
       });
     } catch (error) {
       res.status(500).json({
         error: "Failed to execute migration",
-        message: error instanceof Error ? error.message : "Unknown error"
+        message: sanitizeUntrusted(error, 260)
       });
     }
   });
 }
-var MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_CONFIG_SOURCE_KEYS, CONFLICT_RESOLUTION_SCHEMA, RECONCILE_ACTION_SCHEMA, RECONCILE_PLAN_SCHEMA, PLAN_EXECUTE_PAYLOAD_SCHEMA;
+var MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_CONFIG_SOURCE_KEYS, CONFLICT_RESOLUTION_SCHEMA, RECONCILE_ACTION_SCHEMA, RECONCILE_PLAN_SCHEMA, PLAN_EXECUTE_PAYLOAD_SCHEMA, PLURAL_TO_SINGULAR;
 var init_migration_routes = __esm(() => {
   init_agents_discovery();
   init_commands_discovery();
@@ -51242,6 +51524,13 @@ var init_migration_routes = __esm(() => {
     plan: RECONCILE_PLAN_SCHEMA,
     resolutions: exports_external.record(CONFLICT_RESOLUTION_SCHEMA).optional().default({})
   }).passthrough();
+  PLURAL_TO_SINGULAR = {
+    agents: "agent",
+    commands: "command",
+    skills: "skill",
+    config: "config",
+    rules: "rules"
+  };
 });
 
 // src/services/claude-data/types.ts
@@ -54025,7 +54314,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.35.0-dev.29",
+    version: "3.35.0-dev.30",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -59418,7 +59707,7 @@ var init_websocket_manager = __esm(() => {
 
 // src/domains/web-server/server.ts
 import { createServer } from "node:http";
-import { createConnection } from "node:net";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function createAppServer(options2 = {}) {
   const { port: preferredPort, openBrowser = true, devMode = false } = options2;
   const port = await getPorts({ port: preferredPort || [3456, 3457, 3458, 3459, 3460] });
@@ -59426,76 +59715,89 @@ async function createAppServer(options2 = {}) {
   app.use(import_express2.default.json({ limit: "10mb" }));
   app.use(corsMiddleware);
   registerRoutes(app);
+  const server = createServer(app);
+  server.setTimeout(30000);
+  server.keepAliveTimeout = 65000;
+  server.headersTimeout = 66000;
   if (devMode) {
-    await setupViteDevServer(app);
+    await setupViteDevServer(app, server, { failFast: true });
   } else {
     serveStatic(app);
   }
   app.use(errorHandler);
-  const server = createServer(app);
-  server.setTimeout(30000);
-  server.keepAliveTimeout = 65000;
-  server.headersTimeout = 66000;
-  const wsManager = new WebSocketManager(server);
-  const fileWatcher = new FileWatcher({ wsManager });
-  fileWatcher.start();
-  const portWasInUse = await isPortInUse(port);
-  await new Promise((resolve11, reject) => {
-    server.listen(port, () => resolve11());
-    server.on("error", reject);
-  });
-  logger.debug(`Server listening on port ${port}`);
-  if (openBrowser && !portWasInUse) {
-    try {
-      await open_default(`http://localhost:${port}`);
-    } catch (err) {
-      logger.warning(`Failed to open browser: ${err instanceof Error ? err.message : err}`);
-      logger.info(`Open http://localhost:${port} manually`);
+  let wsManager = null;
+  let fileWatcher = null;
+  try {
+    wsManager = new WebSocketManager(server);
+    fileWatcher = new FileWatcher({ wsManager });
+    fileWatcher.start();
+    await new Promise((resolve11, reject) => {
+      const onListening = () => {
+        server.off("error", onError);
+        resolve11();
+      };
+      const onError = (error) => {
+        server.off("listening", onListening);
+        reject(error);
+      };
+      server.once("listening", onListening);
+      server.once("error", onError);
+      server.listen(port);
+    });
+    logger.debug(`Server listening on port ${port}`);
+    if (openBrowser) {
+      try {
+        await open_default(`http://localhost:${port}`);
+      } catch (err) {
+        logger.warning(`Failed to open browser: ${err instanceof Error ? err.message : err}`);
+        logger.info(`Open http://localhost:${port} manually`);
+      }
     }
+  } catch (error) {
+    fileWatcher?.stop();
+    wsManager?.close();
+    await closeHttpServer(server);
+    throw error;
   }
   return {
     port,
     server,
     close: async () => {
-      fileWatcher.stop();
-      wsManager.close();
-      return new Promise((resolve11) => {
-        if (!server.listening) {
-          resolve11();
-          return;
-        }
-        server.close((err) => {
-          if (err) {
-            logger.debug(`Server close error: ${err.message}`);
-          }
-          resolve11();
-        });
-      });
+      fileWatcher?.stop();
+      wsManager?.close();
+      await closeHttpServer(server);
     }
   };
 }
-function isPortInUse(port) {
-  return new Promise((resolve11) => {
-    const socket = createConnection({ port, host: "127.0.0.1" });
-    socket.once("connect", () => {
-      socket.destroy();
-      resolve11(true);
-    });
-    socket.once("error", () => {
-      socket.destroy();
-      resolve11(false);
+async function closeHttpServer(server) {
+  await new Promise((resolve11) => {
+    if (!server.listening) {
+      resolve11();
+      return;
+    }
+    server.close((err) => {
+      if (err) {
+        logger.debug(`Server close error: ${err.message}`);
+      }
+      resolve11();
     });
   });
 }
-async function setupViteDevServer(app) {
-  const uiRoot = new URL("../../ui", import.meta.url).pathname;
+function resolveUiRootPath() {
+  return fileURLToPath3(new URL("../../ui", import.meta.url));
+}
+async function setupViteDevServer(app, httpServer, options2) {
+  const uiRoot = resolveUiRootPath();
   try {
     const viteEntry = `${uiRoot}/node_modules/vite/dist/node/index.js`;
     const { createServer: createViteServer } = await import(viteEntry);
     const vite = await createViteServer({
       configFile: `${uiRoot}/vite.config.ts`,
       root: uiRoot,
-      server: { middlewareMode: true },
+      server: {
+        middlewareMode: true,
+        hmr: { server: httpServer }
+      },
       appType: "spa"
     });
     app.use(vite.middlewares);
@@ -59503,8 +59805,7 @@ async function setupViteDevServer(app) {
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     console.error(`[dashboard] Vite setup failed: ${msg}`);
-    const isDev = true;
-    if (isDev) {
+    if (options2.failFast) {
       throw error;
     }
     serveStatic(app);
@@ -71541,13 +71842,13 @@ import { execSync as execSync3, spawnSync as spawnSync5 } from "node:child_proce
 import { readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname14, join as join56 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 init_environment();
 init_logger();
 init_dist2();
 function getCliVersion4() {
   try {
-    const __dirname4 = dirname14(fileURLToPath3(import.meta.url));
+    const __dirname4 = dirname14(fileURLToPath4(import.meta.url));
     const pkgPath = join56(__dirname4, "../../../package.json");
     const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
     return pkg.version || "unknown";