@bridge_gpt/mcp-server 0.2.67 → 0.2.69

package/build/check-update-cli.js

@@ -0,0 +1,74 @@
+/**
+ * Internal `check-update` subcommand (BAPI-1446).
+ *
+ * The Claude Code SessionStart hook runs `check-update --hook claude-session-start`
+ * and reads one JSON object from stdout. This command answers from the local
+ * update cache only: it never constructs an MCP server and never touches the
+ * network, so a cold start stays well inside the hook's timeout.
+ *
+ * Protocol:
+ *   - eligible: exactly one newline-terminated JSON object whose
+ *     `systemMessage` (shown to the person) and
+ *     `hookSpecificOutput.additionalContext` (seen by the model) carry the same
+ *     notice text;
+ *   - silent: no output at all;
+ *   - always exit 0 in the supported mode, even after an unexpected error, which
+ *     is contained without logging. A hook must never block a session.
+ *
+ * Any other argument form is a usage error: a concise stderr message and a
+ * nonzero exit.
+ */
+import { getNoticeDecision } from "./session-upgrade-notice.js";
+import { formatSessionUpgradeNotice } from "./upgrade-advice.js";
+import { VERSION } from "./version.generated.js";
+/** The only supported hook mode. */
+export const CLAUDE_SESSION_START_HOOK_MODE = "claude-session-start";
+/** The usage line printed to stderr for an unsupported argument form. */
+export const CHECK_UPDATE_USAGE = `Usage: check-update --hook ${CLAUDE_SESSION_START_HOOK_MODE}`;
+function writeStdout(text) {
+    return new Promise((resolve, reject) => {
+        process.stdout.write(text, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * Run the command. Resolves to the process exit code: 0 for the supported hook
+ * mode (whether or not it printed anything), 2 for any other argument form.
+ */
+export async function runCheckUpdateCli(argv, options = {}) {
+    const stderr = options.stderr ?? ((text) => void process.stderr.write(`${text}\n`));
+    const supported = argv.length === 2 && argv[0] === "--hook" && argv[1] === CLAUDE_SESSION_START_HOOK_MODE;
+    if (!supported) {
+        try {
+            stderr(CHECK_UPDATE_USAGE);
+        }
+        catch {
+            // A stderr failure cannot change the usage-error result.
+        }
+        return 2;
+    }
+    try {
+        const env = options.env ?? process.env;
+        const decision = getNoticeDecision(env, options.version ?? VERSION);
+        if (decision.show) {
+            const notice = formatSessionUpgradeNotice(decision.current, decision.latest);
+            const payload = {
+                systemMessage: notice,
+                hookSpecificOutput: {
+                    hookEventName: "SessionStart",
+                    additionalContext: notice,
+                },
+            };
+            await (options.stdout ?? writeStdout)(`${JSON.stringify(payload)}\n`);
+        }
+    }
+    catch {
+        // Contained without logging: a hook must never fail a session start.
+    }
+    return 0;
+}

package/build/claude-settings.js

@@ -62,8 +62,16 @@ export function mergeClaudeSettingsWithCommandHook(settings, command, events, op
             hooks[event] = entries;
             continue;
         }
-        const newEntry = { hooks: [{ type: "command", command }] };
-        if (event === "PreToolUse") {
+        const leaf = { type: "command", command };
+        const timeout = options.eventTimeouts?.[event];
+        if (timeout !== undefined)
+            leaf.timeout = timeout;
+        const newEntry = { hooks: [leaf] };
+        const eventMatcher = options.eventMatchers?.[event];
+        if (eventMatcher !== undefined) {
+            newEntry.matcher = eventMatcher;
+        }
+        else if (event === "PreToolUse") {
             // Explicit matcher wins; else mirror any existing PreToolUse matcher; else
             // fall back to the broad default.
             newEntry.matcher =
@@ -75,6 +83,80 @@ export function mergeClaudeSettingsWithCommandHook(settings, command, events, op
     }
     return { ...settings, hooks };
 }
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Shape guard for the hook containers a provisioner is about to write into
+ * (BAPI-1446). An ABSENT `hooks` object or event array is fine: it will be
+ * created. A PRESENT one of the wrong type (`hooks` that is an array, a string, or
+ * null; an event that is an object or a string) is `malformed`, and must be
+ * reported and left alone rather than replaced with an empty container.
+ */
+export function inspectClaudeHookContainers(settings, events) {
+    const hooks = settings.hooks;
+    if (hooks === undefined)
+        return "ok";
+    if (!isPlainObject(hooks))
+        return "malformed";
+    for (const event of events) {
+        const entries = hooks[event];
+        if (entries !== undefined && !Array.isArray(entries))
+            return "malformed";
+    }
+    return "ok";
+}
+/**
+ * {@link mergeClaudeSettingsWithCommandHook} behind the shape guard. A malformed
+ * existing container is refused: nothing is merged and the caller's settings are
+ * not touched. Use this for new provisioning; the legacy merge keeps its
+ * original lenient behavior for its existing callers.
+ */
+export function mergeClaudeSettingsWithCommandHookChecked(settings, command, events, options = {}) {
+    const checked = options.enablePreToolUse && !events.includes("PreToolUse")
+        ? [...events, "PreToolUse"]
+        : events;
+    if (inspectClaudeHookContainers(settings, checked) === "malformed") {
+        return { ok: false, reason: "malformed-hooks" };
+    }
+    return { ok: true, settings: mergeClaudeSettingsWithCommandHook(settings, command, events, options) };
+}
+/**
+ * Remove ONE exact command from an event, immutably. Only command leaves whose
+ * command string equals `command` are removed; an entry left with no hooks is
+ * dropped, and everything else (other leaves, other entries, other events, other
+ * settings) is kept as is. Returns the SAME object when nothing matches or the
+ * relevant structure is malformed, so a caller can detect "no change" by identity.
+ * An emptied event array or `hooks` object is left in place: the user may own it.
+ */
+export function removeClaudeSettingsCommandHook(settings, event, command) {
+    const hooks = settings.hooks;
+    if (!isPlainObject(hooks))
+        return settings;
+    const entries = hooks[event];
+    if (!Array.isArray(entries))
+        return settings;
+    let changed = false;
+    const nextEntries = [];
+    for (const entry of entries) {
+        if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) {
+            nextEntries.push(entry);
+            continue;
+        }
+        const leaves = entry.hooks;
+        const kept = leaves.filter((leaf) => !(isPlainObject(leaf) && leaf.type === "command" && leaf.command === command));
+        if (kept.length === leaves.length) {
+            nextEntries.push(entry);
+            continue;
+        }
+        changed = true;
+        if (kept.length > 0)
+            nextEntries.push({ ...entry, hooks: kept });
+    }
+    if (!changed)
+        return settings;
+    return { ...settings, hooks: { ...hooks, [event]: nextEntries } };
+}
 /**
  * Provision (merge into) ONE worktree's `.claude/settings.local.json`. Missing
  * settings are treated as `{}`; malformed JSON is a safety stop (the file is
@@ -127,3 +209,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,27 @@
+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.
+ *
+ * Internal subcommands (`mcp-invoke`, `check-update`) are routed by the
+ * dispatcher but are intentionally not listed: they are launched by tools and
+ * hooks, not typed by a person.
+ */
+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/codex-home.js

@@ -1,7 +1,15 @@
 import path from "node:path";
 import os from "node:os";
+/**
+ * True when `CODEX_HOME` is set to an absolute path, which is the only override
+ * Codex's user config root accepts. A relative or blank value is ignored.
+ */
+export function isCodexHomeOverrideHonored(env) {
+    const override = env.CODEX_HOME?.trim();
+    return Boolean(override) && path.isAbsolute(override);
+}
 /** Codex's user config root; only an absolute CODEX_HOME is accepted. */
 export function codexHome(env, homedir = os.homedir()) {
     const override = env.CODEX_HOME?.trim();
-    return override && path.isAbsolute(override) ? override : path.join(homedir, ".codex");
+    return isCodexHomeOverrideHonored(env) ? override : path.join(homedir, ".codex");
 }