@bridge_gpt/mcp-server 0.2.26 → 0.2.28

package/build/init.js

@@ -33,9 +33,16 @@ export function buildBridgeApiEntry(cwd) {
     // where 0.2.6 persisted despite an upgrade). Pinning keeps the running
     // configuration predictable and visible in version control. The `install-bridge`
     // config write reuses this same entry so both install paths agree.
+    //
+    // `--prefer-offline` makes npx resolve the (immutable, exact-pinned) version
+    // from the local npm cache and skip the redundant registry-metadata round-trip
+    // on every boot, only hitting the network on a genuine cache miss (unlike
+    // `--offline`, it falls back automatically). It cannot resurrect a stale build
+    // — the BAPI-429 hazard above was specific to UNPINNED specs; here the exact
+    // `@${VERSION}` is immutable, so a cache hit is always the right build.
     return {
         command: "npx",
-        args: ["-y", `@bridge_gpt/mcp-server@${VERSION}`],
+        args: ["-y", "--prefer-offline", `@bridge_gpt/mcp-server@${VERSION}`],
         env: {
             BAPI_BASE_URL: "https://bridgegpt-api.com",
             BAPI_REPO_NAME: "YOUR_REPO_NAME",
@@ -143,6 +150,32 @@ async function ensureGitignored(cwd, filePath) {
         mkdir: (p, options) => mkdir(p, options),
     });
 }
+/**
+ * Read-compare-write a single scaffold file. Returns "skipped" when the target
+ * already holds identical bytes (no write), "overwritten" when it existed with
+ * different bytes, and "written" when it was absent. Optionally ensures `mkdirDir`
+ * exists first (used by the DOCS phase, whose targets span different subdirs).
+ *
+ * Extracted so the COMMANDS/DOCS/AGENTS phases can run their per-file work
+ * concurrently via Promise.all instead of one-await-at-a-time: on a slow disk the
+ * sequential syscalls dominated `runInit`. The caller applies each outcome to its
+ * summary Sets AFTER the batch, iterating the ordered results, so behavior and
+ * console output are byte-for-byte identical to the sequential version.
+ */
+async function scaffoldFile(target, content, mkdirDir) {
+    if (mkdirDir !== undefined)
+        await mkdir(mkdirDir, { recursive: true });
+    let existed = false;
+    try {
+        const existing = await readFile(target, "utf-8");
+        if (existing === content)
+            return "skipped";
+        existed = true;
+    }
+    catch { /* file doesn't exist */ }
+    await writeFile(target, content, "utf-8");
+    return existed ? "overwritten" : "written";
+}
 /**
  * Core initialization logic shared by --init and --upgrade.
  * Runs all scaffolding phases without calling process.exit().
@@ -272,22 +305,22 @@ export async function runInit(cwd) {
     const writtenFiles = new Set();
     const skippedFiles = new Set();
     const overwrittenFiles = new Set();
+    const commandEntries = Object.entries(COMMANDS);
     for (const dir of commandDirs) {
         await mkdir(dir, { recursive: true });
-        for (const [filename, content] of Object.entries(COMMANDS)) {
-            const target = path.join(dir, filename);
-            try {
-                const existing = await readFile(target, "utf-8");
-                if (existing === content) {
-                    skippedFiles.add(filename);
-                    continue;
-                }
-                overwrittenFiles.add(filename);
+        // Per-file read/compare/write runs concurrently; outcomes are applied to the
+        // Sets afterward in entry order so the summary counts are unchanged.
+        const outcomes = await Promise.all(commandEntries.map(([filename, content]) => scaffoldFile(path.join(dir, filename), content)));
+        commandEntries.forEach(([filename], i) => {
+            const outcome = outcomes[i];
+            if (outcome === "skipped") {
+                skippedFiles.add(filename);
+                return;
             }
-            catch { /* file doesn't exist */ }
-            await writeFile(target, content, "utf-8");
+            if (outcome === "overwritten")
+                overwrittenFiles.add(filename);
             writtenFiles.add(filename);
-        }
+        });
     }
     // A file written in any directory takes priority over skipped
     for (const f of writtenFiles)
@@ -312,20 +345,21 @@ export async function runInit(cwd) {
     // project root; content is never secret.
     const docsWritten = new Set();
     const docsSkipped = new Set();
-    for (const [relTarget, content] of Object.entries(DOCS)) {
+    const docEntries = Object.entries(DOCS);
+    // Each doc target may live in a different subdir, so mkdir(dirname) happens
+    // per-file inside scaffoldFile. Outcomes applied in entry order below preserve
+    // the insertion order of the joined summary list.
+    const docOutcomes = await Promise.all(docEntries.map(([relTarget, content]) => {
         const target = path.join(cwd, relTarget);
-        await mkdir(path.dirname(target), { recursive: true });
-        try {
-            const existing = await readFile(target, "utf-8");
-            if (existing === content) {
-                docsSkipped.add(relTarget);
-                continue;
-            }
-        }
-        catch { /* file doesn't exist */ }
-        await writeFile(target, content, "utf-8");
-        docsWritten.add(relTarget);
-    }
+        return scaffoldFile(target, content, path.dirname(target));
+    }));
+    docEntries.forEach(([relTarget], i) => {
+        // DOCS tracks only written vs skipped; an overwrite counts as written.
+        if (docOutcomes[i] === "skipped")
+            docsSkipped.add(relTarget);
+        else
+            docsWritten.add(relTarget);
+    });
     const docsTotal = Object.keys(DOCS).length;
     if (docsTotal > 0) {
         console.log(`\nDocumentation: scaffolded ${docsTotal} doc asset${docsTotal === 1 ? "" : "s"}`);
@@ -341,42 +375,32 @@ export async function runInit(cwd) {
     // Always scaffold to .claude/agents/
     const claudeAgentsDir = path.join(cwd, ".claude", "agents");
     await mkdir(claudeAgentsDir, { recursive: true });
-    for (const [key, agent] of Object.entries(AGENTS)) {
-        const filename = `${key}.md`;
-        const content = reconstructAgentMarkdown(agent.frontmatter, agent.body);
-        const target = path.join(claudeAgentsDir, filename);
-        try {
-            const existing = await readFile(target, "utf-8");
-            if (existing === content) {
+    const agentEntries = Object.entries(AGENTS);
+    // Apply a batch of ordered outcomes to the agent Sets (same branches as the
+    // original per-file loop: skipped → skipped; overwritten → overwritten+written;
+    // written → written).
+    const applyAgentOutcomes = (filenames, outcomes) => {
+        filenames.forEach((filename, i) => {
+            const outcome = outcomes[i];
+            if (outcome === "skipped") {
                 agentSkipped.add(filename);
-                continue;
+                return;
             }
-            agentOverwritten.add(filename);
-        }
-        catch { /* file doesn't exist */ }
-        await writeFile(target, content, "utf-8");
-        agentWritten.add(filename);
-    }
+            if (outcome === "overwritten")
+                agentOverwritten.add(filename);
+            agentWritten.add(filename);
+        });
+    };
+    const claudeAgentFilenames = agentEntries.map(([key]) => `${key}.md`);
+    const claudeAgentOutcomes = await Promise.all(agentEntries.map(([key, agent]) => scaffoldFile(path.join(claudeAgentsDir, `${key}.md`), reconstructAgentMarkdown(agent.frontmatter, agent.body))));
+    applyAgentOutcomes(claudeAgentFilenames, claudeAgentOutcomes);
     // Scaffold to .github/agents/ for VS Code / Copilot
     if (ideDetection.vscode) {
         const copilotAgentsDir = path.join(cwd, ".github", "agents");
         await mkdir(copilotAgentsDir, { recursive: true });
-        for (const [key, agent] of Object.entries(AGENTS)) {
-            const filename = `${key}.agent.md`;
-            const content = translateAgentToCopilot(agent.frontmatter, agent.body);
-            const target = path.join(copilotAgentsDir, filename);
-            try {
-                const existing = await readFile(target, "utf-8");
-                if (existing === content) {
-                    agentSkipped.add(filename);
-                    continue;
-                }
-                agentOverwritten.add(filename);
-            }
-            catch { /* file doesn't exist */ }
-            await writeFile(target, content, "utf-8");
-            agentWritten.add(filename);
-        }
+        const copilotAgentFilenames = agentEntries.map(([key]) => `${key}.agent.md`);
+        const copilotAgentOutcomes = await Promise.all(agentEntries.map(([key, agent]) => scaffoldFile(path.join(copilotAgentsDir, `${key}.agent.md`), translateAgentToCopilot(agent.frontmatter, agent.body))));
+        applyAgentOutcomes(copilotAgentFilenames, copilotAgentOutcomes);
     }
     // TODO: Add Cursor agent scaffolding when Cursor publishes a formal agent spec
     // A file written in any directory takes priority over skipped