@bridge_gpt/mcp-server 0.2.67 → 0.2.69

package/build/generated-assets-paths.js

@@ -0,0 +1,60 @@
+import path from "node:path";
+import { validAssetDestination } from "./generated-assets-catalog.js";
+export async function validateAssetRoot(raw, home, fs) {
+    if (!raw || raw.length > 4096 || /[\x00-\x1f\x7f]/.test(raw) || raw.split(/[\\/]/).includes(".."))
+        return null;
+    try {
+        const canonical = await fs.realpath(path.resolve(raw));
+        const info = await fs.lstat(canonical);
+        if (!info.isDirectory() || info.isSymbolicLink() || canonical === path.parse(canonical).root
+            || canonical === await fs.realpath(home))
+            return null;
+        // Validate canonical ancestry; a symlink in the caller's spelling is resolved
+        // once, while later operations use only the printed canonical root.
+        let current = path.parse(canonical).root;
+        for (const segment of path.relative(current, canonical).split(path.sep)) {
+            current = path.join(current, segment);
+            const parent = await fs.lstat(current);
+            if (!parent.isDirectory() || parent.isSymbolicLink())
+                return null;
+        }
+        return canonical;
+    }
+    catch {
+        return null;
+    }
+}
+export function filesystemErrorCode(error) {
+    return error && typeof error === "object" ? error.code : undefined;
+}
+/** Metadata/access only. No asset-body reads and no filesystem mutation. */
+export async function inspectAssetPath(root, destination, fs) {
+    const api = fs.platform === "win32" ? path.win32 : path;
+    if (root.length > 4096 || !api.isAbsolute(root) || /[\x00-\x1f\x7f]/.test(root) || !validAssetDestination(destination)) {
+        return { status: "indeterminate", reason: "unsafe-path" };
+    }
+    let current = api.parse(root).root;
+    const rootSegments = api.relative(current, root).split(api.sep).filter(Boolean);
+    const segments = [...rootSegments, ...destination.split("/")];
+    if (segments.length > 256)
+        return { status: "indeterminate", reason: "path-limit" };
+    for (let i = 0; i < segments.length; i++) {
+        current = api.join(current, segments[i]);
+        try {
+            const info = await fs.lstat(current);
+            if (info.isSymbolicLink())
+                return { status: "indeterminate", reason: "unsafe-link" };
+            const final = i === segments.length - 1;
+            if (final ? !info.isFile() : !info.isDirectory())
+                return { status: "unreadable", reason: "non-file-or-parent" };
+            if (final)
+                await fs.access(current);
+        }
+        catch (error) {
+            if (filesystemErrorCode(error) === "ENOENT" && i >= rootSegments.length)
+                return { status: "missing", reason: "absent" };
+            return { status: "unreadable", reason: filesystemErrorCode(error) === "EACCES" ? "permission-denied" : "metadata-unavailable" };
+        }
+    }
+    return { status: "present", reason: "readable-regular-file" };
+}

package/build/generated-assets-publisher.js

@@ -0,0 +1,133 @@
+import { constants } from "node:fs";
+import { open, mkdir, link, unlink, lstat, realpath } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { validAssetDestination } from "./generated-assets-catalog.js";
+/** Linux procfs provides descriptor-relative paths without adding a native
+ * dependency. Other platforms lack this qualified adapter and fail closed. */
+export function createConfinedAssetPublisher(platform = process.platform) {
+    if (platform !== "linux")
+        return undefined;
+    return { async prepare(root, destination, content) {
+            if (!path.isAbsolute(root) || !validAssetDestination(destination) || path.normalize(root) !== root)
+                throw new Error("Unsafe asset path.");
+            const handles = [];
+            let temporary;
+            let parent;
+            let final;
+            let temporaryOwned = false;
+            const flags = constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+            const descriptorPath = (handle) => `/proc/self/fd/${handle.fd}`;
+            const assertParents = async () => {
+                for (const { handle, expected } of handles) {
+                    const anchor = descriptorPath(handle);
+                    if (await realpath(anchor) !== expected)
+                        throw new Error("Parent confinement changed.");
+                    const current = await lstat(expected);
+                    const held = await handle.stat();
+                    if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== held.dev || current.ino !== held.ino)
+                        throw new Error("Parent confinement changed.");
+                }
+            };
+            const closeHandles = async () => {
+                let failed = false;
+                for (const { handle } of handles.reverse()) {
+                    try {
+                        await handle.close();
+                    }
+                    catch {
+                        failed = true;
+                    }
+                }
+                if (failed)
+                    throw new Error("Descriptor cleanup failed.");
+            };
+            try {
+                // Open the root from / through O_NOFOLLOW directory handles. A substituted
+                // ancestor never redirects a subsequent lookup through the held descriptor.
+                let handle = await open("/", flags);
+                handles.push({ handle, expected: "/" });
+                let expected = "/";
+                const rootSegments = root.split("/").filter(Boolean);
+                const assetSegments = destination.split("/");
+                const parentSegments = assetSegments.slice(0, -1);
+                for (const [index, segment] of [...rootSegments, ...parentSegments].entries()) {
+                    await assertParents();
+                    const child = `${descriptorPath(handle)}/${segment}`;
+                    if (index >= rootSegments.length) {
+                        try {
+                            await mkdir(child);
+                        }
+                        catch (error) {
+                            if (error.code !== "EEXIST")
+                                throw error;
+                        }
+                    }
+                    handle = await open(child, flags);
+                    expected = path.join(expected, segment);
+                    handles.push({ handle, expected });
+                }
+                await assertParents();
+                parent = descriptorPath(handle);
+                temporary = `${parent}/.bridge-repair-${randomUUID()}.tmp`;
+                final = `${parent}/${assetSegments.at(-1)}`;
+                const file = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o644);
+                temporaryOwned = true;
+                try {
+                    await file.writeFile(content, "utf-8");
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                await assertParents();
+                return {
+                    async publish() {
+                        await assertParents();
+                        await link(temporary, final);
+                        // Descriptor-relative publication cannot follow a replacement link.
+                        // Report displaced ancestry as incomplete; never unlink a final path,
+                        // which another creator may already have replaced.
+                        await assertParents();
+                    },
+                    async cleanup() {
+                        let failed = false;
+                        try {
+                            await unlink(temporary);
+                        }
+                        catch {
+                            failed = true;
+                        }
+                        try {
+                            await closeHandles();
+                        }
+                        catch {
+                            failed = true;
+                        }
+                        if (failed)
+                            throw new Error("Owned temporary cleanup failed.");
+                    },
+                };
+            }
+            catch (error) {
+                let cleanupFailed = false;
+                if (temporary && temporaryOwned) {
+                    try {
+                        await unlink(temporary);
+                    }
+                    catch {
+                        cleanupFailed = true;
+                    }
+                }
+                try {
+                    await closeHandles();
+                }
+                catch {
+                    cleanupFailed = true;
+                }
+                if (cleanupFailed)
+                    throw Object.assign(new Error("Owned temporary cleanup failed."), { code: "ASSET_TEMP_CLEANUP_FAILED" });
+                throw error;
+            }
+        } };
+}

package/build/generated-assets-remedy.js

@@ -0,0 +1,25 @@
+import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
+import { VERSION } from "./version.generated.js";
+import { isWorkflowHost } from "./generated-assets-host.js";
+import path from "node:path";
+const quote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+export function packagedAssetRemedy(root, host, version = VERSION, platform = process.platform) {
+    if (!(platform === "win32" ? path.win32 : path).isAbsolute(root) || root.length > 4096 || /[\x00-\x1f\x7f]/.test(root) || !isWorkflowHost(host)
+        || !/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(version))
+        throw new Error("Invalid repair context.");
+    if (platform !== "linux")
+        return { args: [], command: "In-place asset repair is not supported on this platform. Re-run start-tickets to provision worktree assets; for project scaffolds, re-run the existing Bridge --init/install workflow from the established project root.",
+            guidance: "Worktree provisioning preserves existing workflow files. Project init/install follows its existing refresh behavior. Refresh/reconnect the host, then run read-only doctor." };
+    const args = ["-y", `${MCP_PACKAGE_NAME}@${version}`, "repair-assets", "--project-root", root, "--host", host];
+    return { args, command: `npx -y ${MCP_PACKAGE_NAME}@${version} repair-assets --project-root ${quote(root)} --host ${host}`,
+        guidance: "Run from the established project root. Refresh/reconnect the host, then run read-only doctor. If discovery still disagrees with filesystem health, consult host support." };
+}
+export function assetFindingRemedy(finding, root, host, platform = process.platform) {
+    if (finding.status === "missing") {
+        const remedy = packagedAssetRemedy(root, host, VERSION, platform);
+        return `${remedy.command}\n${remedy.guidance}`;
+    }
+    if (finding.status === "present")
+        return "No filesystem repair is needed.";
+    return "Resolve permissions, non-file destinations, or unsafe links before retrying. Repair preserves existing files and refuses unsafe destinations.";
+}

package/build/generated-assets-repair.js

@@ -0,0 +1,72 @@
+import { buildPackagedAssetCatalog, validAssetDestination } from "./generated-assets-catalog.js";
+import { authorizeAssetRepair } from "./generated-assets-context.js";
+import { inspectAssetPath, filesystemErrorCode } from "./generated-assets-paths.js";
+export async function repairPackagedAssets(options) {
+    const catalog = options.catalog ?? buildPackagedAssetCatalog();
+    const result = { complete: false, findings: [], packageProblems: catalog.packageProblems.slice(0, 20), cleanupFailures: [] };
+    if (!authorizeAssetRepair(options.root, options.hosts, options.explicitPair, options.inventory)) {
+        result.packageProblems.push("repair-not-authorized");
+        return result;
+    }
+    const requested = new Map(catalog.assets.filter(a => a.hosts.some(h => options.hosts.includes(h))).map(a => [a.destination, a]));
+    if (!requested.size || requested.size > 1000) {
+        result.packageProblems.push("invalid-requested-catalog");
+        return result;
+    }
+    for (const record of options.inventory?.assets ?? []) {
+        if (options.hosts.includes(record.host) && ![...requested.values()].some(a => a.id === record.id && a.destination === record.destination)) {
+            result.packageProblems.push("recorded-asset-unavailable-in-bundle");
+        }
+    }
+    for (const asset of requested.values()) {
+        if (!validAssetDestination(asset.destination)) {
+            result.findings.push({ destination: "[invalid destination]", status: "failed", reason: "unsafe-path" });
+            continue;
+        }
+        const finding = await inspectAssetPath(options.root, asset.destination, options.fs);
+        if (finding.status === "present") {
+            result.findings.push({ destination: asset.destination, status: "preserved", reason: "existing-readable-file" });
+            continue;
+        }
+        if (finding.status !== "missing") {
+            result.findings.push({ destination: asset.destination, status: finding.status === "unreadable" ? "unreadable" : "failed", reason: finding.reason });
+            continue;
+        }
+        if (!options.publisher) {
+            result.findings.push({ destination: asset.destination, status: "failed", reason: "confined-publication-unsupported" });
+            continue;
+        }
+        let prepared;
+        try {
+            prepared = await options.publisher.prepare(options.root, asset.destination, asset.content);
+            await prepared.publish();
+            result.findings.push({ destination: asset.destination, status: "restored", reason: "exclusive-publication" });
+        }
+        catch (error) {
+            if (filesystemErrorCode(error) === "ASSET_TEMP_CLEANUP_FAILED")
+                result.cleanupFailures.push(asset.destination);
+            if (filesystemErrorCode(error) === "EEXIST") {
+                const winner = await inspectAssetPath(options.root, asset.destination, options.fs);
+                result.findings.push({ destination: asset.destination, status: winner.status === "present" ? "preserved" : "failed",
+                    reason: winner.status === "present" ? "concurrent-creation" : "concurrent-destination-unusable" });
+            }
+            else {
+                result.findings.push({ destination: asset.destination, status: "failed", reason: "publication-or-confinement-failed" });
+            }
+        }
+        finally {
+            if (prepared) {
+                try {
+                    await prepared.cleanup();
+                }
+                catch {
+                    result.cleanupFailures.push(asset.destination);
+                }
+            }
+        }
+    }
+    result.packageProblems = [...new Set(result.packageProblems)].slice(0, 20);
+    result.complete = !result.packageProblems.length && !result.cleanupFailures.length
+        && result.findings.every(f => f.status === "restored" || f.status === "preserved");
+    return result;
+}

package/build/generated-assets-session.js

@@ -0,0 +1,71 @@
+export const ASSET_DISCOVERY_WAIT_MS = 1000;
+export const ASSET_HEALTH_CACHE_MS = 15000;
+export function createAssetHealthSession(options) {
+    const now = options.now ?? Date.now;
+    const setTimer = options.setTimer ?? setTimeout;
+    const clearTimer = options.clearTimer ?? clearTimeout;
+    let snapshot = null;
+    let inspectedAt = -Infinity;
+    let flight;
+    let servedSignature;
+    let generation = 0;
+    let closed = false;
+    let timer;
+    const signature = (advice) => advice ? JSON.stringify([advice.host, advice.command, advice.missingCount, advice.paths, advice.capabilities]) : "";
+    const refresh = () => {
+        if (closed)
+            return Promise.resolve(null);
+        if (flight)
+            return flight;
+        if (now() - inspectedAt < ASSET_HEALTH_CACHE_MS)
+            return Promise.resolve(snapshot);
+        const epoch = generation;
+        const work = Promise.resolve().then(options.inspect).catch(() => null).then(advice => {
+            if (closed || generation !== epoch)
+                return null;
+            snapshot = advice;
+            inspectedAt = now();
+            const next = signature(advice);
+            if (servedSignature !== undefined && servedSignature !== next) {
+                servedSignature = next;
+                try {
+                    void Promise.resolve(options.notify()).catch(() => { });
+                }
+                catch { /* fail open */ }
+            }
+            return advice;
+        }).finally(() => { if (flight === work)
+            flight = undefined; });
+        flight = work;
+        return work;
+    };
+    const schedule = () => {
+        if (closed)
+            return;
+        timer = setTimer(() => { void refresh().finally(schedule); }, ASSET_HEALTH_CACHE_MS);
+        timer.unref?.();
+    };
+    return {
+        start() { if (!timer && !closed) {
+            void refresh();
+            schedule();
+        } },
+        async getAdvisory() {
+            let timeout;
+            try {
+                const advice = await Promise.race([refresh(), new Promise(resolve => {
+                        timeout = setTimer(() => resolve(null), ASSET_DISCOVERY_WAIT_MS);
+                    })]);
+                servedSignature = signature(advice);
+                return advice;
+            }
+            finally {
+                if (timeout)
+                    clearTimer(timeout);
+            }
+        },
+        invalidate() { generation++; snapshot = null; inspectedAt = -Infinity; flight = undefined; },
+        close() { closed = true; generation++; snapshot = null; if (timer)
+            clearTimer(timer); },
+    };
+}

package/build/generated-assets-test-support.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { assetRootBinding } from "./generated-assets-context.js";
+export const asset = (destination = ".claude/commands/implement-ticket.md") => ({
+    id: destination, destination, content: "complete packaged bytes", kind: "command", hosts: ["claude"],
+    workflows: ["implement-ticket"], classification: "entrypoint",
+});
+export const catalog = (assets = [asset()]) => ({ assets, packageProblems: [] });
+export const context = (assets = [asset()]) => ({ root: "/repo", host: "claude",
+    initialized: true, corroborated: true, inventory: { version: 1, packageVersion: "0.1.0", rootBinding: assetRootBinding("/repo"),
+        assets: assets.map(a => ({ id: a.id, destination: a.destination, host: "claude" })) } });
+export function metadataFixture(assets = [asset()]) {
+    const entries = new Map([["/repo", "dir"]]);
+    for (const a of assets) {
+        let parent = path.posix.dirname(`/repo/${a.destination}`);
+        while (parent !== "/") {
+            entries.set(parent, "dir");
+            parent = path.posix.dirname(parent);
+        }
+        entries.set(`/repo/${a.destination}`, "file");
+    }
+    const operations = [];
+    const fs = {
+        platform: "linux",
+        lstat: async (p) => {
+            operations.push(`lstat:${p}`);
+            const type = entries.get(p);
+            if (!type || type === "EACCES")
+                throw Object.assign(new Error("SENTINEL_SECRET_RAW_EXCEPTION"), { code: type ?? "ENOENT" });
+            return { isFile: () => type === "file", isDirectory: () => type === "dir", isSymbolicLink: () => type === "link" };
+        },
+        access: async (p) => { operations.push(`access:${p}`); if (!entries.has(p))
+            throw Object.assign(new Error(), { code: "ENOENT" }); },
+    };
+    return { entries, operations, fs };
+}