@bridge_gpt/mcp-server 0.2.39 → 0.2.42

package/build/plane/preflight.js

@@ -44,6 +44,11 @@ export async function runPlanePreflight(repoRoot, deps) {
         return { ok: false, diagnostics };
     add(await checkClaudeLogin(deps));
     const credentials = await checkBridgeCredentials(repoRoot, deps);
+    // Advisories first, then the failure. An insecure credentials file and an
+    // unresolvable credential are independent facts and can both be true, so the
+    // advisory is appended unconditionally rather than only on the success path.
+    for (const advisory of credentials.advisories)
+        add(advisory);
     if (!credentials.ok)
         add(credentials.diagnostic);
     add(await checkPlaneBuildFreshness(repoRoot, { fs: deps.fs }));
@@ -145,6 +150,24 @@ export async function checkClaudeLogin(deps) {
  * Both go through the shared resolvers. This is the shell-spawned credential
  * rule: a plane member is launched from a spawned shell, which never sees
  * `.mcp.json` env — that file is visible only to the MCP server process.
+ *
+ * ## Permission policy stays with the shared resolver (BAPI-773)
+ *
+ * The resolver owns the group/world-permission rule and the prose it warns
+ * with; plane neither re-implements that policy nor duplicates its threshold.
+ * What plane owns is *delivery*: the resolver writes its advisory to a `stderr`
+ * sink, and an unstructured write straight to the process stream would either
+ * be lost among the structured diagnostics `plane up` renders or interleave
+ * with them unpredictably. So the sink here is a line buffer, and each captured
+ * line becomes a non-blocking `"warning"` diagnostic that flows through the
+ * same rendering path as every other preflight finding.
+ *
+ * The resolver's warning is only as good as the mode it is given, which is why
+ * the stat adapter forwards the real one. When a successful stat carries no
+ * mode at all, `0o777` is substituted *deliberately*: an unknown mode is
+ * reported rather than silently treated as safe. A stat that rejects is left to
+ * reject — fabricating a successful stat out of a filesystem failure would
+ * invent a permission fact that was never observed.
  */
 export async function checkBridgeCredentials(repoRoot, deps) {
     const repo = await deps.resolveRepoName({
@@ -153,8 +176,11 @@ export async function checkBridgeCredentials(repoRoot, deps) {
         readFile: deps.fs.readFile,
     });
     if (!repo.ok) {
+        // Nothing has called the credential resolver yet, so there is no advisory
+        // source to have captured from.
         return {
             ok: false,
+            advisories: [],
             diagnostic: {
                 check: "bridge-credentials",
                 severity: "blocking",
@@ -163,6 +189,7 @@ export async function checkBridgeCredentials(repoRoot, deps) {
             },
         };
     }
+    const warnings = createResolverWarningBuffer();
     let result;
     try {
         result = await deps.resolveCredentials(repo.repoName, {
@@ -171,23 +198,22 @@ export async function checkBridgeCredentials(repoRoot, deps) {
             platform: deps.platform,
             readFile: deps.fs.readFile,
             stat: async (filePath) => {
-                // The resolver only needs POSIX mode bits for its permission warning.
-                // `PlaneFsDeps.stat` is deliberately minimal, so a missing mode is
-                // reported as a fully-open value the resolver will simply warn about
-                // rather than as a fabricated "safe" one.
-                await deps.fs.stat(filePath);
-                return { mode: 0o600 };
-            },
-            stderr: () => {
-                /* the resolver's advisory warnings are not part of plane output */
+                // A rejection propagates untouched: only a *successful* stat that
+                // happens to carry no mode falls back, and it falls back to fully open
+                // so the resolver warns instead of staying silent about an unknown.
+                const statResult = await deps.fs.stat(filePath);
+                return { mode: statResult.mode !== undefined ? statResult.mode : 0o777 };
             },
+            stderr: warnings.write,
         });
     }
     catch {
         // Sanitized: a resolver throw becomes a category, never exception text
-        // (which could echo file contents).
+        // (which could echo file contents). Advisories captured before the throw
+        // are still real observations and are kept.
         return {
             ok: false,
+            advisories: warnings.drain(),
             diagnostic: {
                 check: "bridge-credentials",
                 severity: "blocking",
@@ -199,6 +225,7 @@ export async function checkBridgeCredentials(repoRoot, deps) {
     if (!result.ok) {
         return {
             ok: false,
+            advisories: warnings.drain(),
             diagnostic: {
                 check: "bridge-credentials",
                 severity: "blocking",
@@ -213,6 +240,50 @@ export async function checkBridgeCredentials(repoRoot, deps) {
         repoName: repo.repoName,
         apiKey: result.credentials.apiKey,
         source: result.credentials.source,
+        advisories: warnings.drain(),
+    };
+}
+/**
+ * Line buffer for the shared credential resolver's `stderr` sink.
+ *
+ * The resolver is free to emit a single warning across several callback
+ * invocations, so a chunk is not a line: text is accumulated and only split on
+ * a newline boundary. Whatever remains unterminated when the resolver finishes
+ * is flushed as a final line by `drain`, which is why a resolver that writes
+ * `"third warning"` with no trailing newline still produces a diagnostic.
+ *
+ * Nothing here writes to a process stream. That is the entire point.
+ */
+function createResolverWarningBuffer() {
+    const lines = [];
+    let pending = "";
+    const push = (line) => {
+        const trimmed = line.replace(/\r$/, "");
+        if (trimmed.length === 0)
+            return;
+        lines.push(trimmed);
+    };
+    return {
+        write: (message) => {
+            pending += message;
+            const segments = pending.split("\n");
+            // The final segment is whatever followed the last newline — possibly the
+            // start of a line the resolver has not finished writing yet.
+            pending = segments.pop() ?? "";
+            for (const segment of segments)
+                push(segment);
+        },
+        drain: () => {
+            if (pending.length > 0) {
+                push(pending);
+                pending = "";
+            }
+            return lines.map((message) => ({
+                check: "bridge-credentials",
+                severity: "warning",
+                message,
+            }));
+        },
     };
 }
 /**

package/build/plane/test-fakes.js

@@ -16,6 +16,7 @@ export function dirent(name, kind) {
 export function createFakeFs(options = {}) {
     const files = new Map(Object.entries(options.files ?? {}));
     const mtimes = new Map(Object.entries(options.mtimes ?? {}));
+    const modes = new Map(Object.entries(options.modes ?? {}));
     const dirs = new Map(Object.entries(options.dirs ?? {}));
     const readErrors = new Map(Object.entries(options.readErrors ?? {}));
     const calls = {
@@ -29,6 +30,7 @@ export function createFakeFs(options = {}) {
     return {
         files,
         mtimes,
+        modes,
         calls,
         failNextCreateWith: (code) => {
             pendingCreateFailure = code;
@@ -80,7 +82,13 @@ export function createFakeFs(options = {}) {
                 throw errno(failure);
             if (!files.has(filePath) && !dirs.has(filePath))
                 throw errno("ENOENT");
-            return { mtimeMs: mtimes.get(filePath) ?? 0 };
+            const mode = modes.get(filePath);
+            const result = { mtimeMs: mtimes.get(filePath) ?? 0 };
+            // Assigned only when the fixture supplied one: an absent `mode` must stay
+            // absent, not become `undefined`-shaped-but-present.
+            if (mode !== undefined)
+                result.mode = mode;
+            return result;
         },
         readdir: async (dirPath) => {
             const entries = dirs.get(dirPath);