@bridge_gpt/mcp-server 0.2.67 → 0.2.68

package/build/claude-settings.js

@@ -127,3 +127,21 @@ export async function provisionClaudeSettingsForWorktree(worktreePath, mergeSett
     }
     return { ok: true };
 }
+/**
+ * The Claude Code settings key that turns auto-memory off (BAPI-1397, F6).
+ *
+ * Confirmed against the installed Claude Code 2.1.287: auto-memory is OFF when
+ * the merged settings carry `autoMemoryEnabled: false`, or when the environment
+ * sets `CLAUDE_CODE_DISABLE_AUTO_MEMORY` to a truthy value (which wins over the
+ * setting). Both forms are applied to executor workers.
+ */
+export const CLAUDE_AUTO_MEMORY_SETTING_KEY = "autoMemoryEnabled";
+/** The environment form of the same control; a truthy value turns auto-memory off. */
+export const CLAUDE_DISABLE_AUTO_MEMORY_ENV = "CLAUDE_CODE_DISABLE_AUTO_MEMORY";
+/**
+ * Merge `autoMemoryEnabled: false` into a Claude settings object, keeping every
+ * other entry. Idempotent: re-applying it yields an equal object.
+ */
+export function mergeClaudeSettingsWithAutoMemoryDisabled(settings) {
+    return { ...settings, [CLAUDE_AUTO_MEMORY_SETTING_KEY]: false };
+}

package/build/cli-help.js

@@ -0,0 +1,21 @@
+import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
+/** The one recovery command shared by terminal guidance surfaces. */
+export const INSTALL_RECOVERY_COMMAND = `npx -y ${MCP_PACKAGE_NAME} install`;
+/** Returns static CLI orientation text without resolving configuration or doing I/O. */
+export function getTopLevelCliUsage() {
+    return `Usage: bridge-api-mcp-server [command]
+
+Commands:
+  install  Guided project and MCP host setup.
+  serve    Run the MCP server over stdio.
+No command also starts the stdio MCP server.
+
+Already ran npm i ${MCP_PACKAGE_NAME}?
+The package is installed; project and MCP host setup still need the installer.
+From your intended project root, run:
+${INSTALL_RECOVERY_COMMAND}
+
+No uninstall is needed. Follow the remaining setup instructions.
+Run install --help for detailed installer options.
+`;
+}

package/build/command-assets-doctor.js

@@ -1,72 +1,26 @@
-/**
- * Read-only worktree Claude command-asset diagnostic (doctor-only, BAPI-664).
- *
- * Reports whether the current worktree contains every packaged Claude slash
- * command under `.claude/commands/`. This probe ONLY reads command paths — it
- * never writes, creates directories, invokes Git, spawns a process, compares or
- * reports command file CONTENTS, or leaks raw exceptions. A committed customer
- * version of a command counts as present regardless of its contents (the command
- * bundle is fill-only and never refreshed), so the probe checks presence /
- * readability, not freshness. The sole injected dependencies are `readFile` and
- * `platform`.
- */
-import path from "path";
-import { COMMANDS } from "./commands.generated.js";
-/** Stable user-facing relative location shown in every detail string. */
-const COMMAND_DIR_LABEL = ".claude/commands/";
-/** How many missing filenames to list before summarizing the remainder. */
-const MAX_LISTED_MISSING = 5;
-/** The `path` API for the target platform (win32 vs posix). */
-function pathApiForPlatform(platform) {
-    return platform === "win32" ? path.win32 : path.posix;
-}
-/** Render a bounded, deterministic list of missing filenames (generated order). */
-function formatMissing(missing) {
-    if (missing.length <= MAX_LISTED_MISSING) {
-        return missing.join(", ");
-    }
-    const shown = missing.slice(0, MAX_LISTED_MISSING).join(", ");
-    return `${shown} (+${missing.length - MAX_LISTED_MISSING} more)`;
-}
-/**
- * Probe whether `<worktreeRoot>/.claude/commands/` contains every packaged
- * command asset. A `readFile` that resolves counts the asset as present (any
- * contents); a rejection (missing OR unreadable) counts it as absent. Returns
- * `found: true` only when every packaged command filename is present, otherwise a
- * `found: false` result with a concise, actionable, secret-free detail that
- * points the operator back to `start-tickets` (never to manually copying or
- * committing generated files).
- */
-export async function probeWorktreeCommandAssets(worktreeRoot, deps) {
-    const filenames = Object.keys(COMMANDS);
-    if (filenames.length === 0) {
-        return {
-            found: false,
-            detail: "Packaged command bundle is empty — reinstall or rebuild the MCP server package.",
-        };
-    }
-    const api = pathApiForPlatform(deps.platform);
-    const commandsDir = api.join(worktreeRoot, ".claude", "commands");
-    const missing = [];
-    for (const filename of filenames) {
-        try {
-            await deps.readFile(api.join(commandsDir, filename));
-        }
-        catch {
-            // Missing OR unreadable — either way the asset is not usable. We never
-            // surface the underlying error (it can carry paths / exception text).
-            missing.push(filename);
-        }
-    }
-    if (missing.length === 0) {
-        return {
-            found: true,
-            detail: `${filenames.length} packaged command assets present under ${COMMAND_DIR_LABEL}`,
-        };
+/** Metadata-only compatibility probe for worktree command assets. */
+import { buildPackagedAssetCatalog } from "./generated-assets-catalog.js";
+import { inspectPackagedDependency } from "./generated-assets-health.js";
+import { packagedAssetRemedy } from "./generated-assets-remedy.js";
+export async function probeWorktreeCommandAssets(root, deps) {
+    if (!deps.metadata)
+        return { found: false, detail: "Command-asset inspection indeterminate (metadata access unavailable)." };
+    const catalog = buildPackagedAssetCatalog();
+    const assets = catalog.assets.filter(a => a.kind === "command" && a.hosts.includes("claude"));
+    if (!assets.length || catalog.packageProblems.length)
+        return { found: false, detail: "Packaged command bundle is empty or unavailable — rebuild or reinstall the package." };
+    const findings = [];
+    const deadline = Date.now() + 1000;
+    for (const asset of assets) {
+        if (Date.now() >= deadline)
+            return { found: false, detail: "Command-asset inspection indeterminate (time budget)." };
+        findings.push(await inspectPackagedDependency(root, asset, { ...deps.metadata, platform: deps.platform }, deadline - Date.now()));
     }
-    return {
-        found: false,
-        detail: `${missing.length} of ${filenames.length} packaged command assets missing or unreadable under ` +
-            `${COMMAND_DIR_LABEL} (${formatMissing(missing)}). Re-run start-tickets to provision them.`,
-    };
+    const unusable = findings.filter(f => f.status !== "present");
+    if (!unusable.length)
+        return { found: true, detail: `${assets.length} packaged command assets present under .claude/commands/` };
+    const shown = unusable.slice(0, 5).map(f => `${f.destination.split("/").at(-1)}: ${f.status} (${f.reason})`).join(", ");
+    const missing = unusable.filter(f => f.status === "missing").length;
+    const guidance = missing ? packagedAssetRemedy(root, "claude", undefined, deps.platform).command : "Resolve path/permission problems; use explicit --project-root and --host for provisioning.";
+    return { found: false, detail: `${unusable.length} of ${assets.length} packaged command assets unusable under .claude/commands/ (${shown}${unusable.length > 5 ? `, +${unusable.length - 5} more` : ""}). ${guidance}` };
 }

package/build/command-provisioning.js

@@ -25,8 +25,7 @@
  * and rendered by the caller's existing orchestration boundary.
  */
 import path from "path";
-import { COMMANDS } from "./commands.generated.js";
-import { codexSkillAssets } from "./codex-skill-adapter.js";
+import { buildPackagedAssetCatalog } from "./generated-assets-catalog.js";
 import { ensureGitInfoExcluded } from "./git-ignore-utils.js";
 /** The exact exclude entry appended for the command directory (POSIX-relative). */
 const COMMAND_DIR_EXCLUDE_ENTRY = ".claude/commands/";
@@ -59,7 +58,10 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
         ? api.normalize(worktreeRoot)
         : api.resolve(deps.cwd, worktreeRoot);
     const commandsDir = api.join(normalizedRoot, ".claude", "commands");
-    const entries = Object.entries(COMMANDS);
+    const catalog = buildPackagedAssetCatalog();
+    const commandAssets = catalog.assets.filter(a => a.kind === "command" && a.hosts.includes("claude"));
+    const entries = commandAssets.map(a => [api.basename(a.destination), a.content]);
+    const successful = [];
     if (entries.length === 0) {
         // No runnable slash commands could ever be provisioned — fail loudly rather
         // than reporting a hollow success.
@@ -74,6 +76,9 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
         const target = api.join(commandsDir, filename);
         try {
             await deps.readFile(target);
+            const asset = commandAssets.find(a => api.basename(a.destination) === filename);
+            if (asset)
+                successful.push(asset);
         }
         catch (err) {
             if (isEnoentError(err)) {
@@ -92,6 +97,9 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
             await deps.mkdir(commandsDir, { recursive: true });
             for (const [filename, content] of missing) {
                 await deps.writeFile(api.join(commandsDir, filename), content);
+                const asset = commandAssets.find(a => api.basename(a.destination) === filename);
+                if (asset)
+                    successful.push(asset);
             }
         }
         catch {
@@ -102,8 +110,8 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
     // Codex launch requires the full bundle. Fill only, preserving customer assets.
     if (!fillError && includeCodexSkills) {
         try {
-            for (const asset of codexSkillAssets(COMMANDS)) {
-                const target = api.join(normalizedRoot, asset.relativePath);
+            for (const asset of catalog.assets.filter(a => a.kind === "skill" && a.hosts.includes("codex"))) {
+                const target = api.join(normalizedRoot, asset.destination);
                 try {
                     await deps.readFile(target);
                 }
@@ -113,6 +121,7 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
                     await deps.mkdir(api.dirname(target), { recursive: true });
                     await deps.writeFile(target, asset.content);
                 }
+                successful.push(asset);
             }
         }
         catch {
@@ -131,6 +140,13 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
             runCommand: deps.runCommand,
             platform: deps.platform,
         });
+        if (deps.recordAssets) {
+            // Inventory is machine-local state, just like the generated workflow files.
+            await ensureGitInfoExcluded(normalizedRoot, ".bridge/install-state.json", {
+                readFile: deps.readFile, writeFile: deps.writeFile, mkdir: deps.mkdir,
+                runCommand: deps.runCommand, platform: deps.platform,
+            });
+        }
         if (includeCodexSkills) {
             await ensureGitInfoExcluded(normalizedRoot, CODEX_SKILLS_EXCLUDE_ENTRY, {
                 readFile: deps.readFile,
@@ -145,6 +161,14 @@ export async function provisionCommandsForWorktree(worktreeRoot, deps, includeCo
         excludeError =
             "Command provisioning failed: could not add generated command assets to the worktree Git exclude file.";
     }
+    if (deps.recordAssets && successful.length) {
+        try {
+            await deps.recordAssets(normalizedRoot, successful, includeCodexSkills ? ["claude", "codex"] : ["claude"]);
+        }
+        catch {
+            fillError ??= "Command provisioning failed: could not record packaged workflow inventory.";
+        }
+    }
     if (fillError)
         return { ok: false, error: fillError };
     if (excludeError)