dlw-machine-setup 0.4.6 → 0.4.8

package/bin/installer.js

@@ -3244,6 +3244,47 @@ var import_fs5 = require("fs");
 var import_readline = require("readline");
 var import_path5 = require("path");
 
+// src/utils/fetch.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 2e3;
+async function fetchWithTimeout(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeoutMs / 1e3}s`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchWithRetry(url, options = {}, maxRetries = DEFAULT_MAX_RETRIES, retryDelayMs = DEFAULT_RETRY_DELAY_MS) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetchWithTimeout(url, options);
+      if (!response.ok && response.status >= 400 && response.status < 500 && response.status !== 429) {
+        return response;
+      }
+      if (response.ok) {
+        return response;
+      }
+      lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+    if (attempt < maxRetries) {
+      const delay = retryDelayMs * Math.pow(2, attempt - 1);
+      await new Promise((resolve3) => setTimeout(resolve3, delay));
+    }
+  }
+  throw lastError || new Error("Failed after maximum retries");
+}
+
 // src/utils/data/fetch-wizard-options.ts
 async function fetchWizardOptions(token, repo) {
   try {
@@ -3251,7 +3292,7 @@ async function fetchWizardOptions(token, repo) {
       "Accept": "application/vnd.github+json",
       "Authorization": `Bearer ${token}`
     };
-    const releaseRes = await fetch(
+    const releaseRes = await fetchWithRetry(
       `https://api.github.com/repos/${repo}/releases/latest`,
       { headers }
     );
@@ -3259,7 +3300,7 @@ async function fetchWizardOptions(token, repo) {
     const release = await releaseRes.json();
     const asset = release.assets?.find((a) => a.name === "wizard-options.json");
     if (!asset) return null;
-    const assetRes = await fetch(asset.url, {
+    const assetRes = await fetchWithRetry(asset.url, {
       headers: { ...headers, "Accept": "application/octet-stream" }
     });
     if (!assetRes.ok) return null;
@@ -3267,7 +3308,7 @@ async function fetchWizardOptions(token, repo) {
     if (!Array.isArray(data.agents) || !Array.isArray(data.personas?.personas)) {
       return null;
     }
-    return data;
+    return { options: data, releaseVersion: release.tag_name ?? "unknown" };
   } catch {
     return null;
   }
@@ -3276,8 +3317,6 @@ async function fetchWizardOptions(token, repo) {
 // src/utils/data/discover-repo.ts
 var GITHUB_ORG = "DLW-INT-SAP-DEV";
 var REPO_TOPIC = "one-shot-data";
-var MAX_RETRIES = 3;
-var RETRY_DELAY_MS = 2e3;
 async function discoverRepo(token) {
   const headers = {
     "Accept": "application/vnd.github+json",
@@ -3339,25 +3378,6 @@ async function tryOrgReposList(headers) {
     return null;
   }
 }
-async function fetchWithRetry(url, options) {
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      const response = await fetch(url, options);
-      if (!response.ok && response.status >= 400 && response.status < 500 && response.status !== 429) {
-        return response;
-      }
-      if (response.ok) return response;
-      lastError = new Error(`HTTP ${response.status}`);
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-    }
-    if (attempt < MAX_RETRIES) {
-      await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS * Math.pow(2, attempt - 1)));
-    }
-  }
-  return new Response(null, { status: 503, statusText: "Retry exhausted" });
-}
 
 // src/utils/data/fetch-contexts.ts
 var import_fs2 = require("fs");
@@ -3409,7 +3429,7 @@ function clearTokenCache() {
   }
 }
 async function requestDeviceCode() {
-  const response = await fetch(GITHUB_DEVICE_CODE_URL, {
+  const response = await fetchWithTimeout(GITHUB_DEVICE_CODE_URL, {
     method: "POST",
     headers: {
       "Accept": "application/json",
@@ -3431,7 +3451,7 @@ async function pollForToken(deviceCode, interval) {
   let attempts = 0;
   while (attempts < maxAttempts) {
     await new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
-    const response = await fetch(GITHUB_TOKEN_URL, {
+    const response = await fetchWithTimeout(GITHUB_TOKEN_URL, {
       method: "POST",
       headers: {
         "Accept": "application/json",
@@ -3472,7 +3492,11 @@ async function pollForToken(deviceCode, interval) {
 async function authenticateWithGitHub() {
   const envToken = process.env.GITHUB_TOKEN;
   if (envToken) {
-    return envToken;
+    const isValid = await verifyToken(envToken);
+    if (isValid) {
+      return envToken;
+    }
+    console.log("  GITHUB_TOKEN env var is invalid or expired, falling back to authentication...\n");
   }
   const cachedToken = loadCachedToken();
   if (cachedToken) {
@@ -3504,7 +3528,7 @@ async function authenticateWithGitHub() {
 }
 async function verifyToken(token) {
   try {
-    const response = await fetch("https://api.github.com/user", {
+    const response = await fetchWithTimeout("https://api.github.com/user", {
       headers: {
         "Authorization": `Bearer ${token}`,
         "Accept": "application/vnd.github+json"
@@ -3520,8 +3544,6 @@ async function getGitHubToken() {
 }
 
 // src/utils/data/fetch-contexts.ts
-var MAX_RETRIES2 = 3;
-var RETRY_DELAY_MS2 = 2e3;
 var MIN_FILE_SIZE = 1024;
 async function fetchContexts(options = {}) {
   const { domains = [], targetDir = process.cwd(), force = false, token, repo } = options;
@@ -3545,7 +3567,7 @@ async function fetchContexts(options = {}) {
       "Accept": "application/vnd.github+json",
       "Authorization": `Bearer ${githubToken}`
     };
-    const releaseResponse = await fetchWithRetry2(releaseUrl, { headers }, MAX_RETRIES2);
+    const releaseResponse = await fetchWithRetry(releaseUrl, { headers });
     if (!releaseResponse.ok) {
       throw new Error(
         `GitHub API error (${releaseResponse.status}): ${getReadableError(releaseResponse.status)}`
@@ -3583,7 +3605,7 @@ async function fetchContexts(options = {}) {
           "Authorization": `Bearer ${githubToken}`
         };
         const downloadUrl = asset.url;
-        const response = await fetchWithRetry2(downloadUrl, { headers: downloadHeaders }, MAX_RETRIES2);
+        const response = await fetchWithRetry(downloadUrl, { headers: downloadHeaders });
         if (!response.ok) {
           throw new Error(`Download failed: ${getReadableError(response.status)}`);
         }
@@ -3605,14 +3627,17 @@ async function fetchContexts(options = {}) {
             throw new Error(`Archive contains unsafe path: ${entry}`);
           }
         }
-        (0, import_child_process.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
+        const extractResult = (0, import_child_process.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
+        if (extractResult.status !== 0) {
+          throw new Error("Archive extraction failed");
+        }
         const extractedEntries = (0, import_fs2.readdirSync)(tempDir);
         const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === domain.toLowerCase());
         if (!extractedFolder) {
           throw new Error("Extraction failed");
         }
         const extractedPath = (0, import_path2.join)(tempDir, extractedFolder);
-        mergeDirectories(extractedPath, domainPath);
+        copyDirectory(extractedPath, domainPath);
         result.successful.push(domain);
       } catch (error) {
         const reason = error instanceof Error ? error.message : "Unknown error";
@@ -3646,28 +3671,6 @@ async function checkPrerequisites() {
     );
   }
 }
-async function fetchWithRetry2(url, options, maxRetries) {
-  let lastError = null;
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      const response = await fetch(url, options);
-      if (!response.ok && response.status >= 400 && response.status < 500 && response.status !== 429) {
-        return response;
-      }
-      if (response.ok) {
-        return response;
-      }
-      lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-    }
-    if (attempt < maxRetries) {
-      const delay = RETRY_DELAY_MS2 * Math.pow(2, attempt - 1);
-      await new Promise((resolve3) => setTimeout(resolve3, delay));
-    }
-  }
-  throw lastError || new Error("Failed after maximum retries");
-}
 function getReadableError(status) {
   switch (status) {
     case 401:
@@ -3686,9 +3689,9 @@ function getReadableError(status) {
       return `Unexpected error (${status})`;
   }
 }
-function mergeDirectories(source, target) {
+function copyDirectory(source, target) {
   let added = 0;
-  let skipped = 0;
+  let overwritten = 0;
   if (!(0, import_fs2.existsSync)(target)) {
     (0, import_fs2.mkdirSync)(target, { recursive: true });
   }
@@ -3697,19 +3700,19 @@ function mergeDirectories(source, target) {
     const sourcePath = (0, import_path2.join)(source, entry.name);
     const targetPath = (0, import_path2.join)(target, entry.name);
     if (entry.isDirectory()) {
-      const result = mergeDirectories(sourcePath, targetPath);
+      const result = copyDirectory(sourcePath, targetPath);
       added += result.added;
-      skipped += result.skipped;
+      overwritten += result.overwritten;
     } else {
       if ((0, import_fs2.existsSync)(targetPath)) {
-        skipped++;
+        overwritten++;
       } else {
-        (0, import_fs2.copyFileSync)(sourcePath, targetPath);
         added++;
       }
+      (0, import_fs2.copyFileSync)(sourcePath, targetPath);
     }
   }
-  return { added, skipped };
+  return { added, overwritten };
 }
 
 // src/utils/setup/setup-mcp.ts
@@ -3735,28 +3738,36 @@ async function setupMCPConfiguration(projectPath, mcpConfig, agent) {
       (0, import_fs3.mkdirSync)(dir, { recursive: true });
     }
   }
+  const red2 = (text) => `\x1B[31m${text}\x1B[0m`;
   let existingFile = {};
   if ((0, import_fs3.existsSync)(mcpJsonPath)) {
     try {
       const content = (0, import_fs3.readFileSync)(mcpJsonPath, "utf-8");
       existingFile = JSON.parse(content);
     } catch {
+      const box = [
+        "",
+        red2("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
+        red2("  \u2551  \u26A0  MCP CONFIG HAS INVALID JSON                 \u2551"),
+        red2("  \u2551                                                  \u2551"),
+        red2(`  \u2551  ${target.filePath} could not be parsed.`.padEnd(52) + "\u2551"),
+        red2("  \u2551  Existing MCP servers may be lost.               \u2551"),
+        red2("  \u2551  Check the file after installation completes.    \u2551"),
+        red2("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
+        ""
+      ].join("\n");
+      console.log(box);
     }
   }
-  const existing = existingFile[target.rootKey] ?? {};
   const addedServers = [];
   const skippedServers = [];
-  const mergedServers = { ...existing };
+  const servers = {};
   for (const [serverName, serverConfig] of Object.entries(mcpConfig)) {
-    if (mergedServers[serverName]) {
-      skippedServers.push(serverName);
-    } else {
-      const { description, useWhen, active, ...mcpFields } = serverConfig;
-      mergedServers[serverName] = mcpFields;
-      addedServers.push(serverName);
-    }
+    const { description, useWhen, active, ...mcpFields } = serverConfig;
+    servers[serverName] = mcpFields;
+    addedServers.push(serverName);
   }
-  const outputFile = { ...existingFile, [target.rootKey]: mergedServers };
+  const outputFile = { ...existingFile, [target.rootKey]: servers };
   (0, import_fs3.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
   return { addedServers, skippedServers };
 }
@@ -3780,9 +3791,9 @@ function buildMCPConfiguration(selectedItems, baseMcpServers, allMcpServers) {
 // src/utils/setup/setup-instructions.ts
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var CONTEXTS_DIR = (0, import_path4.join)(process.cwd(), "_ai-context");
 var MARKER_START = "<!-- one-shot-installer:start -->";
 var MARKER_END = "<!-- one-shot-installer:end -->";
+var red = (text) => `\x1B[31m${text}\x1B[0m`;
 function upsertBlock(filePath, block) {
   const marked = `${MARKER_START}
 ${block}
@@ -3794,7 +3805,27 @@ ${MARKER_END}`;
   const existing = (0, import_fs4.readFileSync)(filePath, "utf-8");
   const start = existing.indexOf(MARKER_START);
   const end = existing.indexOf(MARKER_END);
-  if (start !== -1 && end !== -1) {
+  const hasStart = start !== -1;
+  const hasEnd = end !== -1;
+  if (hasStart && !hasEnd || !hasStart && hasEnd || hasStart && hasEnd && end < start) {
+    const fileName = filePath.split(/[/\\]/).pop() ?? filePath;
+    const box = [
+      "",
+      red("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
+      red("  \u2551  \u26A0  INSTRUCTION FILE COULD NOT BE UPDATED       \u2551"),
+      red("  \u2551                                                  \u2551"),
+      red(`  \u2551  ${fileName} has corrupted markers.`.padEnd(52) + "\u2551"),
+      red("  \u2551  Fix: delete the lines containing                \u2551"),
+      red("  \u2551    <!-- one-shot-installer:start -->             \u2551"),
+      red("  \u2551    <!-- one-shot-installer:end -->               \u2551"),
+      red("  \u2551  Then re-run the installer.                      \u2551"),
+      red("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
+      ""
+    ].join("\n");
+    console.log(box);
+    throw new Error(`Corrupted markers in ${fileName} \u2014 fix manually and re-run`);
+  }
+  if (hasStart && hasEnd) {
     const updated = existing.slice(0, start) + marked + existing.slice(end + MARKER_END.length);
     (0, import_fs4.writeFileSync)(filePath, updated, "utf-8");
   } else {
@@ -3845,19 +3876,19 @@ function buildMCPSection(mcpConfig) {
   }
   return lines2.join("\n");
 }
-function resolveDomainFolder(domain) {
-  if ((0, import_fs4.existsSync)(CONTEXTS_DIR)) {
+function resolveDomainFolder(domain, contextsDir) {
+  if ((0, import_fs4.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs4.readdirSync)(CONTEXTS_DIR);
+      const entries = (0, import_fs4.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
       if (match) {
-        return { folderName: match, folderPath: (0, import_path4.join)(CONTEXTS_DIR, match) };
+        return { folderName: match, folderPath: (0, import_path4.join)(contextsDir, match) };
       }
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path4.join)(CONTEXTS_DIR, fallback) };
+  return { folderName: fallback, folderPath: (0, import_path4.join)(contextsDir, fallback) };
 }
 function formatPathRef(contextPath, description, agent) {
   if (agent === "github-copilot") {
@@ -3865,7 +3896,7 @@ function formatPathRef(contextPath, description, agent) {
   }
   return `- \`${contextPath}\` \u2014 ${description}`;
 }
-function buildContextRefsSection(domains, agent) {
+function buildContextRefsSection(domains, agent, contextsDir) {
   const lines2 = [
     `## Context References`,
     ``,
@@ -3874,7 +3905,7 @@ function buildContextRefsSection(domains, agent) {
   ];
   let hasAnyFiles = false;
   for (const domain of domains) {
-    const { folderName, folderPath: domainPath } = resolveDomainFolder(domain);
+    const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
     if (!(0, import_fs4.existsSync)(domainPath)) continue;
     const domainFiles = [];
     const ctxInstructions = (0, import_path4.join)(domainPath, "context-instructions.md");
@@ -3919,29 +3950,30 @@ function buildContextRefsSection(domains, agent) {
   }
   return lines2.join("\n");
 }
-function buildCombinedInstructions(domains, mcpConfig, agent = "") {
+function buildCombinedInstructions(domains, mcpConfig, agent = "", projectPath = process.cwd()) {
+  const contextsDir = (0, import_path4.join)(projectPath, "_ai-context");
   const lines2 = [
     `# AI Development Instructions`,
     ``,
     `> Generated by One-Shot Installer`,
     ``
   ];
-  lines2.push(buildContextRefsSection(domains, agent));
+  lines2.push(buildContextRefsSection(domains, agent, contextsDir));
   if (mcpConfig && Object.keys(mcpConfig).length > 0) {
     lines2.push(buildMCPSection(mcpConfig));
   }
   return lines2.join("\n");
 }
 async function setupInstructions(config) {
-  const { domains, agent, mcpConfig } = config;
+  const { domains, agent, mcpConfig, projectPath = process.cwd() } = config;
   switch (agent) {
     case "claude-code": {
-      const content = buildCombinedInstructions(domains, mcpConfig, agent);
-      upsertBlock((0, import_path4.join)(process.cwd(), "CLAUDE.md"), content);
+      const content = buildCombinedInstructions(domains, mcpConfig, agent, projectPath);
+      upsertBlock((0, import_path4.join)(projectPath, "CLAUDE.md"), content);
       break;
     }
     case "github-copilot": {
-      const agentsDir = (0, import_path4.join)(process.cwd(), ".github", "agents");
+      const agentsDir = (0, import_path4.join)(projectPath, ".github", "agents");
       if (!(0, import_fs4.existsSync)(agentsDir)) (0, import_fs4.mkdirSync)(agentsDir, { recursive: true });
       const filePath = (0, import_path4.join)(agentsDir, "instructions.md");
       if (!(0, import_fs4.existsSync)(filePath)) {
@@ -3951,14 +3983,14 @@ applyTo: "**"
 
 `, "utf-8");
       }
-      const body = buildCombinedInstructions(domains, mcpConfig, agent);
+      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath);
       upsertBlock(filePath, body);
       break;
     }
     case "cursor": {
-      const cursorDir = (0, import_path4.join)(process.cwd(), ".cursor", "rules");
+      const cursorDir = (0, import_path4.join)(projectPath, ".cursor", "rules");
       if (!(0, import_fs4.existsSync)(cursorDir)) (0, import_fs4.mkdirSync)(cursorDir, { recursive: true });
-      const body = buildCombinedInstructions(domains, mcpConfig, agent);
+      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath);
       upsertBlock((0, import_path4.join)(cursorDir, `instructions.mdc`), body);
       break;
     }
@@ -3973,18 +4005,21 @@ async function loadWizardOptions(token, repo) {
   if (!remote) {
     throw new Error("Failed to load configuration from GitHub release. Check your network and token.");
   }
+  const { options, releaseVersion } = remote;
   const filteredMcpServers = Object.fromEntries(
-    Object.entries(remote.mcpServers).filter(([, config]) => config.active !== false)
+    Object.entries(options.mcpServers).filter(([, config]) => config.active !== false)
   );
   return {
-    personas: remote.personas.personas.filter((p) => p.active !== false),
-    agents: remote.agents.filter((a) => a.active !== false),
-    baseMcpServers: remote.personas.baseMcpServers,
-    mcpServers: filteredMcpServers
+    personas: options.personas.personas.filter((p) => p.active !== false),
+    agents: options.agents.filter((a) => a.active !== false),
+    baseMcpServers: options.personas.baseMcpServers,
+    mcpServers: filteredMcpServers,
+    releaseVersion
   };
 }
 
 // src/index.ts
+var INSTALLER_VERSION = "0.4.8";
 function getInstructionFilePath(agent) {
   switch (agent) {
     case "claude-code":
@@ -4031,7 +4066,7 @@ async function main() {
     const repo = await discoverRepo(token);
     console.log("  Loading configuration...");
     const options = await loadWizardOptions(token, repo);
-    const config = await collectInputs(options);
+    const config = await collectInputs(options, options.releaseVersion);
     if (!config) {
       await waitForEnter();
       return;
@@ -4050,7 +4085,7 @@ async function main() {
     await waitForEnter();
   }
 }
-async function collectInputs(options) {
+async function collectInputs(options, releaseVersion) {
   const selectedIds = await esm_default2({
     message: "Personas:",
     instructions: "  Space to select  \xB7  Enter to confirm",
@@ -4089,7 +4124,9 @@ async function collectInputs(options) {
     agent,
     azureDevOpsOrg,
     projectPath: (0, import_path5.resolve)(projectInput),
-    mcpConfig
+    baseMcpServers: options.baseMcpServers,
+    mcpConfig,
+    releaseVersion
   };
 }
 async function previewAndConfirm(config, options) {
@@ -4141,7 +4178,7 @@ async function execute(config, token, repo) {
   const domainValues = uniqueDomains.map((d) => d.toLowerCase());
   console.log(`  Downloading contexts...`);
   try {
-    const downloadResult = await fetchContexts({ domains: domainValues, token, repo });
+    const downloadResult = await fetchContexts({ domains: domainValues, token, repo, targetDir: config.projectPath });
     result.domainsInstalled = downloadResult.successful;
     result.domainsFailed = downloadResult.failed;
     result.failureReasons = downloadResult.failureReasons;
@@ -4162,28 +4199,26 @@ async function execute(config, token, repo) {
     result.success = false;
     return result;
   }
+  const successfulDomains = new Set(result.domainsInstalled);
+  const successfulPersonas = config.personas.filter(
+    (p) => p.domains.every((d) => successfulDomains.has(d.toLowerCase()))
+  );
+  const successfulMcpServers = /* @__PURE__ */ new Set([
+    ...config.baseMcpServers,
+    ...successfulPersonas.flatMap((p) => p.mcpServers)
+  ]);
+  const filteredMcpConfig = Object.fromEntries(
+    Object.entries(config.mcpConfig).filter(([name]) => successfulMcpServers.has(name))
+  );
   const statePath = (0, import_path5.join)(config.projectPath, ".one-shot-state.json");
-  let previousState = {};
-  try {
-    if ((0, import_fs5.existsSync)(statePath)) {
-      previousState = JSON.parse((0, import_fs5.readFileSync)(statePath, "utf-8"));
-    }
-  } catch {
-  }
-  const allDomains = [.../* @__PURE__ */ new Set([
-    ...previousState.domains ?? [],
-    ...result.domainsInstalled
-  ])];
-  const mergedMcpConfig = {
-    ...previousState.mcpConfigs ?? {},
-    ...config.mcpConfig
-  };
+  const allDomains = result.domainsInstalled;
   process.stdout.write(`  Writing ${instructionFilePath}...    `);
   try {
     await setupInstructions({
       domains: allDomains,
       agent: config.agent,
-      mcpConfig: mergedMcpConfig
+      mcpConfig: filteredMcpConfig,
+      projectPath: config.projectPath
     });
     result.instructionsCreated = true;
     console.log("\u2713");
@@ -4196,7 +4231,7 @@ async function execute(config, token, repo) {
   try {
     const mcpResult = await setupMCPConfiguration(
       config.projectPath,
-      config.mcpConfig,
+      filteredMcpConfig,
       config.agent
     );
     result.mcpConfigured = true;
@@ -4208,17 +4243,17 @@ async function execute(config, token, repo) {
     console.log(`    Path:  ${mcpConfigPath}`);
   }
   result.success = result.domainsFailed.length === 0 && result.instructionsCreated && result.mcpConfigured;
-  const allPersonas = [.../* @__PURE__ */ new Set([
-    ...previousState.personas ?? [],
-    ...config.personas.map((p) => p.id)
-  ])];
+  const allPersonas = config.personas.map((p) => p.id);
   const state = {
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    installerVersion: INSTALLER_VERSION,
+    releaseVersion: config.releaseVersion,
+    projectPath: config.projectPath,
     agent: config.agent,
     personas: allPersonas,
     domains: allDomains,
-    mcpServers: Object.keys(mergedMcpConfig),
-    mcpConfigs: mergedMcpConfig,
+    mcpServers: Object.keys(filteredMcpConfig),
+    mcpConfigs: filteredMcpConfig,
     files: {
       instructions: instructionFilePath,
       mcpConfig: mcpConfigPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dlw-machine-setup",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "One-shot installer for The Machine toolchain",
   "bin": {
     "dlw-machine-setup": "bin/installer.js"