@gugu910/pi-slack-bridge 0.1.3

package/dist/broker-delivery.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrokerDeliveryState = createBrokerDeliveryState;
+exports.resetBrokerDeliveryState = resetBrokerDeliveryState;
+exports.isBrokerInboxIdTracked = isBrokerInboxIdTracked;
+exports.queueBrokerInboxIds = queueBrokerInboxIds;
+exports.markBrokerInboxIdsHandled = markBrokerInboxIdsHandled;
+exports.getBrokerInboxIds = getBrokerInboxIds;
+function createBrokerDeliveryState() {
+    return {
+        pendingInboxIds: new Set(),
+    };
+}
+function resetBrokerDeliveryState(state) {
+    state.pendingInboxIds.clear();
+}
+function isBrokerInboxIdTracked(state, inboxId) {
+    return state.pendingInboxIds.has(inboxId);
+}
+function queueBrokerInboxIds(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.pendingInboxIds.add(inboxId);
+    }
+}
+function markBrokerInboxIdsHandled(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.pendingInboxIds.delete(inboxId);
+    }
+}
+function getBrokerInboxIds(messages) {
+    return [
+        ...new Set(messages.flatMap((message) => (message.brokerInboxId ? [message.brokerInboxId] : []))),
+    ];
+}

package/dist/canvases.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSlackCanvasCreateKind = normalizeSlackCanvasCreateKind;
+exports.normalizeSlackCanvasUpdateMode = normalizeSlackCanvasUpdateMode;
+exports.normalizeSlackCanvasSectionType = normalizeSlackCanvasSectionType;
+exports.buildSlackCanvasCreateRequest = buildSlackCanvasCreateRequest;
+exports.buildSlackCanvasEditRequest = buildSlackCanvasEditRequest;
+exports.buildSlackCanvasSectionsLookupRequest = buildSlackCanvasSectionsLookupRequest;
+exports.pickSlackCanvasSectionId = pickSlackCanvasSectionId;
+exports.extractSlackChannelCanvasId = extractSlackChannelCanvasId;
+exports.extractExistingChannelCanvasId = extractExistingChannelCanvasId;
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+function buildDocumentContent(markdown) {
+    if (markdown == null || markdown.length === 0)
+        return undefined;
+    return { type: "markdown", markdown };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.map(asString).filter((item) => Boolean(item));
+    return strings.length > 0 ? strings : undefined;
+}
+function normalizeSlackCanvasCreateKind(kind) {
+    const normalized = kind?.trim().toLowerCase();
+    if (!normalized)
+        return "standalone";
+    if (normalized === "standalone" || normalized === "channel") {
+        return normalized;
+    }
+    throw new Error("Unsupported canvas kind. Use 'standalone' or 'channel'.");
+}
+function normalizeSlackCanvasUpdateMode(mode) {
+    const normalized = mode?.trim().toLowerCase();
+    if (!normalized)
+        return "append";
+    if (normalized === "append" || normalized === "prepend" || normalized === "replace") {
+        return normalized;
+    }
+    throw new Error("Unsupported canvas update mode. Use 'append', 'prepend', or 'replace'.");
+}
+function normalizeSlackCanvasSectionType(type) {
+    const normalized = type?.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "h1" ||
+        normalized === "h2" ||
+        normalized === "h3" ||
+        normalized === "any_header") {
+        return normalized;
+    }
+    throw new Error("Unsupported canvas section type. Use 'h1', 'h2', 'h3', or 'any_header'.");
+}
+function buildSlackCanvasCreateRequest(input) {
+    const kind = normalizeSlackCanvasCreateKind(input.kind);
+    const channelId = normalizeOptionalString(input.channelId);
+    const title = normalizeOptionalString(input.title);
+    const documentContent = buildDocumentContent(input.markdown);
+    if (kind === "channel") {
+        if (!channelId) {
+            throw new Error("Channel canvases require a channel.");
+        }
+        return {
+            kind,
+            method: "conversations.canvases.create",
+            body: {
+                ...(title ? { title } : {}),
+                ...(documentContent ? { document_content: documentContent } : {}),
+                channel_id: channelId,
+            },
+        };
+    }
+    return {
+        kind,
+        method: "canvases.create",
+        body: {
+            ...(title ? { title } : {}),
+            ...(documentContent ? { document_content: documentContent } : {}),
+            ...(channelId ? { channel_id: channelId } : {}),
+        },
+    };
+}
+function buildSlackCanvasEditRequest(input) {
+    const canvasId = normalizeOptionalString(input.canvasId);
+    if (!canvasId) {
+        throw new Error("Canvas updates require a canvas ID.");
+    }
+    if (input.markdown.length === 0) {
+        throw new Error("Canvas updates require markdown content.");
+    }
+    const sectionId = normalizeOptionalString(input.sectionId);
+    const mode = normalizeSlackCanvasUpdateMode(input.mode);
+    const operation = mode === "append" ? "insert_at_end" : mode === "prepend" ? "insert_at_start" : "replace";
+    return {
+        canvas_id: canvasId,
+        changes: [
+            {
+                operation,
+                document_content: { type: "markdown", markdown: input.markdown },
+                ...(sectionId ? { section_id: sectionId } : {}),
+            },
+        ],
+    };
+}
+function buildSlackCanvasSectionsLookupRequest(input) {
+    const canvasId = normalizeOptionalString(input.canvasId);
+    if (!canvasId) {
+        throw new Error("Canvas section lookups require a canvas ID.");
+    }
+    const containsText = normalizeOptionalString(input.containsText);
+    if (!containsText) {
+        throw new Error("Canvas section lookups require text to match.");
+    }
+    const sectionType = normalizeSlackCanvasSectionType(input.sectionType);
+    return {
+        canvas_id: canvasId,
+        criteria: {
+            contains_text: containsText,
+            ...(sectionType ? { section_types: [sectionType] } : {}),
+        },
+    };
+}
+function pickSlackCanvasSectionId(sections, sectionIndex) {
+    const matches = (sections ?? [])
+        .map((section) => normalizeOptionalString(section.id))
+        .filter((id) => Boolean(id));
+    if (matches.length === 0) {
+        throw new Error("No canvas sections matched the lookup.");
+    }
+    if (sectionIndex != null) {
+        if (!Number.isInteger(sectionIndex) || sectionIndex < 1) {
+            throw new Error("section_index must be a positive integer.");
+        }
+        const selected = matches[sectionIndex - 1];
+        if (!selected) {
+            throw new Error(`Canvas section lookup matched ${matches.length} sections; section_index ${sectionIndex} is out of range.`);
+        }
+        return selected;
+    }
+    if (matches.length > 1) {
+        throw new Error(`Canvas section lookup matched ${matches.length} sections. Provide section_index to choose one result or narrow the lookup.`);
+    }
+    return matches[0];
+}
+function extractSlackChannelCanvasId(response) {
+    const channel = asRecord(response.channel);
+    const properties = asRecord(channel?.properties);
+    if (!properties)
+        return null;
+    const directCanvas = asString(properties.canvas);
+    if (directCanvas)
+        return directCanvas;
+    const canvasRecord = asRecord(properties.canvas);
+    const canvasId = asString(canvasRecord?.id) ?? asString(canvasRecord?.canvas_id);
+    if (canvasId)
+        return canvasId;
+    const channelSolutions = asRecord(properties.channel_solutions);
+    const canvasIds = asStringArray(channelSolutions?.canvas_ids);
+    if (canvasIds?.[0])
+        return canvasIds[0];
+    return null;
+}
+function extractExistingChannelCanvasId(response) {
+    const canvasId = extractSlackChannelCanvasId(response);
+    return canvasId;
+}

package/dist/deploy-manifest.js

@@ -0,0 +1,238 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffManifestScopes = diffManifestScopes;
+exports.formatScopeChangeSummary = formatScopeChangeSummary;
+exports.resolveDeployConfig = resolveDeployConfig;
+exports.getDeployConfigError = getDeployConfigError;
+exports.deploySlackManifest = deploySlackManifest;
+exports.run = run;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_url_1 = require("node:url");
+const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
+class SlackMethodError extends Error {
+    method;
+    slackError;
+    details;
+    constructor(method, slackError, details = []) {
+        const detailMessage = details
+            .map((detail) => {
+            const pointer = detail.pointer ? `${detail.pointer}: ` : "";
+            return `- ${pointer}${detail.message ?? "unknown error"}`;
+        })
+            .join("\n");
+        super(detailMessage
+            ? `Slack ${method}: ${slackError}\n${detailMessage}`
+            : `Slack ${method}: ${slackError}`);
+        this.name = "SlackMethodError";
+        this.method = method;
+        this.slackError = slackError;
+        this.details = details;
+    }
+}
+function loadSettings(settingsPath) {
+    const resolvedPath = settingsPath ??
+        path.join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".pi", "agent", "settings.json");
+    try {
+        const content = fs.readFileSync(resolvedPath, "utf-8");
+        const parsed = JSON.parse(content);
+        return (parsed["slack-bridge"] ??
+            {});
+    }
+    catch {
+        return {};
+    }
+}
+function buildSlackRequest(method, token, body) {
+    const headers = {
+        Authorization: `Bearer ${token}`,
+    };
+    let serialized;
+    if (body) {
+        headers["Content-Type"] = "application/json; charset=utf-8";
+        serialized = JSON.stringify(body);
+    }
+    return {
+        url: `https://slack.com/api/${method}`,
+        init: {
+            method: "POST",
+            headers,
+            ...(serialized ? { body: serialized } : {}),
+        },
+    };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readScopeList(manifest, scopeType) {
+    const oauthConfig = asRecord(manifest?.oauth_config);
+    const scopes = asRecord(oauthConfig?.scopes);
+    const raw = scopes?.[scopeType];
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return [
+        ...new Set(raw.filter((item) => typeof item === "string" && item.length > 0)),
+    ].sort();
+}
+function diffManifestScopes(beforeManifest, afterManifest) {
+    const beforeBot = new Set(readScopeList(beforeManifest, "bot"));
+    const afterBot = new Set(readScopeList(afterManifest, "bot"));
+    const beforeUser = new Set(readScopeList(beforeManifest, "user"));
+    const afterUser = new Set(readScopeList(afterManifest, "user"));
+    const diff = (next, prev) => [...next].filter((scope) => !prev.has(scope)).sort();
+    return {
+        addedBotScopes: diff(afterBot, beforeBot),
+        removedBotScopes: diff(beforeBot, afterBot),
+        addedUserScopes: diff(afterUser, beforeUser),
+        removedUserScopes: diff(beforeUser, afterUser),
+    };
+}
+function formatScopeChangeSummary(changes) {
+    const lines = [];
+    if (changes.addedBotScopes.length > 0) {
+        lines.push(`Bot scopes added: ${changes.addedBotScopes.join(", ")}`);
+    }
+    if (changes.removedBotScopes.length > 0) {
+        lines.push(`Bot scopes removed: ${changes.removedBotScopes.join(", ")}`);
+    }
+    if (changes.addedUserScopes.length > 0) {
+        lines.push(`User scopes added: ${changes.addedUserScopes.join(", ")}`);
+    }
+    if (changes.removedUserScopes.length > 0) {
+        lines.push(`User scopes removed: ${changes.removedUserScopes.join(", ")}`);
+    }
+    return lines.length > 0 ? lines : ["No scope changes."];
+}
+function resolveDeployConfig(settings, env, cwd = process.cwd()) {
+    return {
+        manifestPath: path.join(cwd, "slack-bridge", "manifest.yaml"),
+        appId: settings.appId ?? env.SLACK_APP_ID,
+        appConfigToken: settings.appConfigToken ?? env.SLACK_APP_CONFIG_TOKEN ?? env.SLACK_CONFIG_TOKEN,
+        appToken: settings.appToken ?? env.SLACK_APP_TOKEN,
+    };
+}
+function getDeployConfigError(config) {
+    if (!fs.existsSync(config.manifestPath)) {
+        return `Slack manifest not found at ${config.manifestPath}`;
+    }
+    const messages = [];
+    if (!config.appId) {
+        messages.push("Missing Slack app ID. Set slack-bridge.appId in ~/.pi/agent/settings.json or SLACK_APP_ID.");
+    }
+    if (!config.appConfigToken) {
+        const appTokenNote = config.appToken
+            ? " Note: slack-bridge.appToken / SLACK_APP_TOKEN is a Socket Mode xapp token and cannot be used with apps.manifest.update."
+            : "";
+        messages.push("Missing Slack app configuration token. Set slack-bridge.appConfigToken in ~/.pi/agent/settings.json or SLACK_APP_CONFIG_TOKEN (or SLACK_CONFIG_TOKEN)." +
+            appTokenNote);
+    }
+    return messages.length > 0 ? messages.join(" ") : null;
+}
+async function parseManifestYaml(manifestPath) {
+    try {
+        const program = [
+            "require 'yaml'",
+            "require 'json'",
+            "data = YAML.load_file(ARGV[0])",
+            "puts JSON.generate(data)",
+        ].join("; ");
+        const { stdout } = await execFile("ruby", ["-e", program, manifestPath]);
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${manifestPath} via Ruby YAML parser. Ensure Ruby is installed and the manifest is valid YAML. ${String(error)}`);
+    }
+}
+async function callSlackMethod(method, token, body) {
+    const { url, init } = buildSlackRequest(method, token, body);
+    const response = await fetch(url, init);
+    const payload = (await response.json());
+    if (!response.ok || payload.ok !== true) {
+        throw new SlackMethodError(method, payload.error ?? `http_${response.status}`, payload.errors ?? []);
+    }
+    return payload;
+}
+async function exportRemoteManifest(appId, token) {
+    const payload = await callSlackMethod("apps.manifest.export", token, { app_id: appId });
+    return payload.manifest;
+}
+async function validateManifest(manifest, token) {
+    await callSlackMethod("apps.manifest.validate", token, {
+        manifest: JSON.stringify(manifest),
+    });
+}
+async function updateManifest(appId, manifest, token) {
+    await callSlackMethod("apps.manifest.update", token, {
+        app_id: appId,
+        manifest: JSON.stringify(manifest),
+    });
+}
+async function deploySlackManifest(config) {
+    const configError = getDeployConfigError(config);
+    if (configError) {
+        throw new Error(configError);
+    }
+    const appId = config.appId;
+    const appConfigToken = config.appConfigToken;
+    const manifest = await parseManifestYaml(config.manifestPath);
+    const previousManifest = await exportRemoteManifest(appId, appConfigToken);
+    await validateManifest(manifest, appConfigToken);
+    await updateManifest(appId, manifest, appConfigToken);
+    const updatedManifest = await exportRemoteManifest(appId, appConfigToken);
+    return {
+        appId,
+        scopeChanges: diffManifestScopes(previousManifest, updatedManifest),
+    };
+}
+async function run() {
+    const settingsPath = process.env.PI_SETTINGS_PATH;
+    const settings = loadSettings(settingsPath);
+    const config = resolveDeployConfig(settings, process.env);
+    const result = await deploySlackManifest(config);
+    console.log(`Updated Slack app ${result.appId} from ${config.manifestPath}`);
+    for (const line of formatScopeChangeSummary(result.scopeChanges)) {
+        console.log(line);
+    }
+}
+if (process.argv[1] && import.meta.url === (0, node_url_1.pathToFileURL)(process.argv[1]).href) {
+    run().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/follower-delivery.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFollowerDeliveryState = createFollowerDeliveryState;
+exports.resetFollowerDeliveryState = resetFollowerDeliveryState;
+exports.isFollowerInboxIdTracked = isFollowerInboxIdTracked;
+exports.queueFollowerInboxIds = queueFollowerInboxIds;
+exports.markFollowerInboxIdsDelivered = markFollowerInboxIdsDelivered;
+exports.hasDeliveredFollowerInboxIds = hasDeliveredFollowerInboxIds;
+exports.takeFollowerAckBatch = takeFollowerAckBatch;
+exports.markFollowerAckBatchSucceeded = markFollowerAckBatchSucceeded;
+exports.markFollowerAckBatchFailed = markFollowerAckBatchFailed;
+exports.drainFollowerAckBatches = drainFollowerAckBatches;
+exports.getFollowerShutdownAckIds = getFollowerShutdownAckIds;
+function createFollowerDeliveryState() {
+    return {
+        queuedButUndeliveredIds: new Set(),
+        deliveredAwaitingAckIds: new Set(),
+        ackInFlightIds: new Set(),
+    };
+}
+function resetFollowerDeliveryState(state) {
+    state.queuedButUndeliveredIds.clear();
+    state.deliveredAwaitingAckIds.clear();
+    state.ackInFlightIds.clear();
+}
+function isFollowerInboxIdTracked(state, inboxId) {
+    return (state.queuedButUndeliveredIds.has(inboxId) ||
+        state.deliveredAwaitingAckIds.has(inboxId) ||
+        state.ackInFlightIds.has(inboxId));
+}
+function queueFollowerInboxIds(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.queuedButUndeliveredIds.add(inboxId);
+    }
+}
+function markFollowerInboxIdsDelivered(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.queuedButUndeliveredIds.delete(inboxId);
+        state.deliveredAwaitingAckIds.add(inboxId);
+    }
+}
+function hasDeliveredFollowerInboxIds(state) {
+    return state.deliveredAwaitingAckIds.size > 0;
+}
+function takeFollowerAckBatch(state) {
+    const batch = [...state.deliveredAwaitingAckIds];
+    for (const inboxId of batch) {
+        state.deliveredAwaitingAckIds.delete(inboxId);
+        state.ackInFlightIds.add(inboxId);
+    }
+    return batch;
+}
+function markFollowerAckBatchSucceeded(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.ackInFlightIds.delete(inboxId);
+    }
+}
+function markFollowerAckBatchFailed(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        if (state.ackInFlightIds.delete(inboxId)) {
+            state.deliveredAwaitingAckIds.add(inboxId);
+        }
+    }
+}
+async function drainFollowerAckBatches(state, ackBatch) {
+    while (true) {
+        const batch = takeFollowerAckBatch(state);
+        if (batch.length === 0) {
+            return;
+        }
+        try {
+            await ackBatch(batch);
+            markFollowerAckBatchSucceeded(state, batch);
+        }
+        catch {
+            markFollowerAckBatchFailed(state, batch);
+            return;
+        }
+    }
+}
+function getFollowerShutdownAckIds(state) {
+    return [...state.deliveredAwaitingAckIds];
+}

package/dist/git-metadata.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeGitBranch = probeGitBranch;
+exports.probeGitContext = probeGitContext;
+exports.createGitContextCache = createGitContextCache;
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function runGitCommand(args, cwd, runner) {
+    try {
+        const result = await runner("git", args, { cwd, encoding: "utf-8" });
+        const stdout = typeof result.stdout === "string" ? result.stdout : result.stdout?.toString();
+        const trimmed = stdout?.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function probeGitBranch(cwd = process.cwd(), runner = execFileAsync) {
+    return runGitCommand(["branch", "--show-current"], cwd, runner);
+}
+async function probeGitContext(cwd = process.cwd(), runner = execFileAsync) {
+    const repoRoot = await runGitCommand(["rev-parse", "--show-toplevel"], cwd, runner);
+    const branch = await probeGitBranch(cwd, runner);
+    const resolvedRepoRoot = repoRoot ?? cwd;
+    return {
+        cwd,
+        repo: path.basename(resolvedRepoRoot),
+        repoRoot,
+        branch,
+    };
+}
+function createGitContextCache(loader) {
+    let cached = null;
+    let inflight = null;
+    return {
+        async get() {
+            if (cached)
+                return cached;
+            if (inflight)
+                return inflight;
+            inflight = loader()
+                .then((result) => {
+                cached = result;
+                return result;
+            })
+                .finally(() => {
+                inflight = null;
+            });
+            return inflight;
+        },
+        peek() {
+            return cached;
+        },
+        clear() {
+            cached = null;
+            inflight = null;
+        },
+    };
+}