@wardby/cli 0.6.0 → 0.8.0

package/dist/core/mark-ready.js

@@ -0,0 +1,152 @@
+import { lastPusher } from "./budget-stopped-head.js";
+import { pullRequestOutcome } from "./host-status.js";
+import { MERGE_ORDER_CHECK_NAME } from "./merge-order-check.js";
+const CI_GREEN = new Set(["passing", "none"]);
+/** How far up the run tree (Run.parentRunId) the opt-in may come from. */
+const MAX_ANCESTOR_HOPS = 10;
+const CODING_RUN_SELECT = {
+    runId: true,
+    repository: true,
+    rootCodingRunId: true,
+    markedReadyAt: true,
+    result: true,
+    run: { select: { agentId: true, parentRunId: true, status: true } },
+};
+const passed = (c) => c !== undefined && c.status === "completed" && c.conclusion === "success";
+export async function maybeMarkReady(deps, repository, prNumber, provider) {
+    try {
+        const host = deps.hosts?.[provider];
+        if (!host?.pullRequestOrigin || !host.readOwnChecks || !host.readCi || !host.markReadyForReview)
+            return "off";
+        const links = await deps.db.agentRepository.findMany({
+            where: { provider, repository },
+            select: {
+                agentId: true,
+                access: true,
+                triggers: true,
+                checkName: true,
+                markReadyWhenPassing: true,
+                authorizedVia: true,
+            },
+        });
+        const optedIn = new Set(links
+            .filter((l) => l.access === "write" && l.authorizedVia !== null && l.markReadyWhenPassing)
+            .map((l) => l.agentId));
+        if (optedIn.size === 0)
+            return "off";
+        const reviewChecks = links
+            .filter((l) => l.access === "write" && l.authorizedVia !== null && l.triggers.includes("pull_request") && l.checkName)
+            .map((l) => l.checkName);
+        if (reviewChecks.length === 0)
+            return "not_ready";
+        // readOwnChecks reads at most 10 names; MERGE_ORDER_CHECK_NAME plus the reviewer
+        // check names must fit, or the merge-order check would silently be read as absent.
+        if (reviewChecks.length > 9)
+            return "not_ready";
+        const origin = await host.pullRequestOrigin(repository, prNumber);
+        if (origin.state !== "open" || origin.draft !== true || origin.isFork || !origin.markerRunId)
+            return "not_ready";
+        const marked = await deps.db.codingRun.findUnique({
+            where: { runId: origin.markerRunId },
+            select: CODING_RUN_SELECT,
+        });
+        if (!marked)
+            return "not_ready";
+        const root = marked.rootCodingRunId
+            ? await deps.db.codingRun.findUnique({ where: { runId: marked.rootCodingRunId }, select: CODING_RUN_SELECT })
+            : marked;
+        if (!root || root.repository.toLowerCase() !== repository.toLowerCase())
+            return "not_ready";
+        if (pullRequestOutcome(root.result)?.pullRequestNumber !== prNumber)
+            return "not_ready";
+        if (!(await optedInInRunTree(deps.db, root.run, optedIn)))
+            return "not_ready";
+        if (root.markedReadyAt)
+            return "skipped";
+        if (await lastPushStoppedAtBudget(deps.db, root, prNumber))
+            return "not_ready";
+        const checks = await host.readOwnChecks(repository, origin.headSha, [MERGE_ORDER_CHECK_NAME, ...reviewChecks]);
+        if (!reviewChecks.every((name) => passed(checks.get(name))))
+            return "not_ready";
+        const order = checks.get(MERGE_ORDER_CHECK_NAME);
+        if (order !== undefined && !passed(order))
+            return "not_ready";
+        const ci = await host.readCi(repository, origin.headSha);
+        if (!CI_GREEN.has(ci.state) || ci.truncated)
+            return "not_ready";
+        const claimedAt = new Date();
+        // CodingRun.updatedAt is @updatedAt, so this claim (and a release below) bumps it, which
+        // feeds the merge-order sweep's ordering. Harmless: the sweep re-derives state from the
+        // host each time, it doesn't rely on updatedAt being untouched by mark-ready.
+        const claim = await deps.db.codingRun.updateMany({
+            where: { runId: root.runId, markedReadyAt: null },
+            data: { markedReadyAt: claimedAt },
+        });
+        if (claim.count === 0)
+            return "skipped";
+        const release = () => deps.db.codingRun
+            .updateMany({ where: { runId: root.runId, markedReadyAt: claimedAt }, data: { markedReadyAt: null } })
+            .catch((err) => deps.log?.warn({ err, repository, prNumber }, "could not release the mark-ready claim"));
+        try {
+            const result = await host.markReadyForReview(repository, prNumber, origin.headSha, origin.markerRunId);
+            if (result === "marked") {
+                deps.log?.info({ repository, prNumber }, "marked the pull request ready for review");
+                return "marked";
+            }
+            await release();
+            return "skipped";
+        }
+        catch (err) {
+            await release();
+            throw err;
+        }
+    }
+    catch (err) {
+        deps.log?.warn({ err, repository, prNumber }, "could not mark the pull request ready for review");
+        return "failed";
+    }
+}
+/**
+ * Whether the last run that pushed to the pull request (the root, or a later continuation of it)
+ * stopped at its budget: its pushed changes are unfinished work, so the draft stays a draft. A
+ * continuation that finished the work makes it eligible again.
+ */
+async function lastPushStoppedAtBudget(db, root, prNumber) {
+    return (await lastPusher(db, root, prNumber)).status === "budget_exhausted";
+}
+/**
+ * True when the opener's agent, or an agent up its run tree (bounded, cycle-safe), is opted in.
+ * A coding run's parentRunId is set when a lead delegated to it.
+ */
+async function optedInInRunTree(db, opener, optedIn) {
+    if (optedIn.has(opener.agentId))
+        return true;
+    const seen = new Set();
+    let next = opener.parentRunId ?? null;
+    for (let hop = 0; next && hop < MAX_ANCESTOR_HOPS && !seen.has(next); hop++) {
+        seen.add(next);
+        const run = await db.run.findUnique({ where: { id: next }, select: { agentId: true, parentRunId: true } });
+        if (!run)
+            return false;
+        if (optedIn.has(run.agentId))
+            return true;
+        next = run.parentRunId;
+    }
+    return false;
+}
+/** After a reviewer run ends: evaluate the pull request it reviewed. Null when it reviewed none. */
+export async function markReadyAfterRun(deps, runId) {
+    try {
+        const row = await deps.db.runHostCheck.findUnique({
+            where: { runId },
+            select: { provider: true, repository: true, prNumber: true, verdict: true },
+        });
+        if (!row || row.prNumber === null || !row.verdict)
+            return null;
+        return await maybeMarkReady(deps, row.repository, row.prNumber, row.provider);
+    }
+    catch (err) {
+        deps.log?.warn({ err, runId }, "could not evaluate mark-ready after the run");
+        return "failed";
+    }
+}

package/dist/core/markdown-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitHub-flavoured Markdown with its code removed, so a mention quoted in code
+ * (`` `@app` ``, a fenced or indented block) is documentation, not a request.
+ * Close to CommonMark, not a full parser: when in doubt it keeps text, so a
+ * real mention is never lost to an odd construct.
+ */
+/** `markdown` without its code blocks and inline code spans. */
+export declare function withoutMarkdownCode(markdown: string): string;

package/dist/core/markdown-code.js

@@ -0,0 +1,107 @@
+/**
+ * GitHub-flavoured Markdown with its code removed, so a mention quoted in code
+ * (`` `@app` ``, a fenced or indented block) is documentation, not a request.
+ * Close to CommonMark, not a full parser: when in doubt it keeps text, so a
+ * real mention is never lost to an odd construct.
+ */
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+const INDENTED = /^(?: {4}|\t)/;
+const LIST_ITEM = /^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+const BLANK = /^\s*$/;
+/** Up to three spaces, at least the opening run of the fence's character, then only whitespace. */
+function closesFence(line, fence) {
+    let index = 0;
+    while (index < 3 && line[index] === " ")
+        index += 1;
+    const start = index;
+    while (line[index] === fence.char)
+        index += 1;
+    return index - start >= fence.length && line.slice(index).trim() === "";
+}
+/** Fenced and indented code blocks blanked out, line count kept. */
+function withoutCodeBlocks(markdown) {
+    const out = [];
+    let fence = null;
+    // Indented code needs a blank line before it, and indented text under a
+    // list item is the item's paragraph, not code.
+    let previousBlank = true;
+    let inIndentedCode = false;
+    let inList = false;
+    for (const line of markdown.split(/\r?\n/)) {
+        if (fence) {
+            if (closesFence(line, fence))
+                fence = null;
+            out.push("");
+            continue;
+        }
+        const open = FENCE_OPEN.exec(line);
+        // A backtick fence's info string cannot contain a backtick (CommonMark).
+        if (open && !(open[1][0] === "`" && line.slice(line.indexOf(open[1]) + open[1].length).includes("`"))) {
+            fence = { char: open[1][0], length: open[1].length };
+            inIndentedCode = false;
+            previousBlank = false;
+            out.push("");
+            continue;
+        }
+        if (BLANK.test(line)) {
+            previousBlank = true;
+            out.push(line);
+            continue;
+        }
+        if (INDENTED.test(line) && !inList && (previousBlank || inIndentedCode)) {
+            inIndentedCode = true;
+            previousBlank = false;
+            out.push("");
+            continue;
+        }
+        inIndentedCode = false;
+        if (LIST_ITEM.test(line))
+            inList = true;
+        else if (!INDENTED.test(line) && previousBlank)
+            inList = false;
+        previousBlank = false;
+        out.push(line);
+    }
+    return out;
+}
+/** Inline code spans in one paragraph replaced by a space; an unmatched run of backticks is literal. */
+function withoutCodeSpans(paragraph) {
+    const runs = [];
+    for (let index = 0; index < paragraph.length;) {
+        if (paragraph[index] !== "`") {
+            index += 1;
+            continue;
+        }
+        const start = index;
+        while (paragraph[index] === "`")
+            index += 1;
+        runs.push({ start, end: index });
+    }
+    // A span closes at the next run of exactly the opening run's length.
+    const closer = new Array(runs.length).fill(-1);
+    const nextOfLength = new Map();
+    for (let i = runs.length - 1; i >= 0; i--) {
+        const length = runs[i].end - runs[i].start;
+        closer[i] = nextOfLength.get(length) ?? -1;
+        nextOfLength.set(length, i);
+    }
+    let result = "";
+    let copied = 0;
+    for (let i = 0; i < runs.length; i++) {
+        const close = closer[i];
+        if (close === -1)
+            continue;
+        result += `${paragraph.slice(copied, runs[i].start)} `;
+        copied = runs[close].end;
+        i = close;
+    }
+    return result + paragraph.slice(copied);
+}
+/** `markdown` without its code blocks and inline code spans. */
+export function withoutMarkdownCode(markdown) {
+    return withoutCodeBlocks(markdown)
+        .join("\n")
+        .split(/(\n[ \t]*\n)/)
+        .map((part, i) => (i % 2 === 1 ? part : withoutCodeSpans(part)))
+        .join("");
+}

package/dist/core/mcp-client/client.d.ts

@@ -0,0 +1,47 @@
+export interface McpHttpRequest {
+    method: "POST" | "DELETE";
+    headers: Record<string, string>;
+    body?: string;
+}
+export interface McpHttpResponse {
+    status: number;
+    /** Header names are lower-case. */
+    headers: Record<string, string>;
+    body: string;
+}
+/** The transport: in production brokeredFetch + safeFetch; in tests a fake. Throws only for network-level failures. */
+export type McpFetch = (request: McpHttpRequest, signal: AbortSignal) => Promise<McpHttpResponse>;
+export interface McpToolEntry {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: Record<string, unknown>;
+}
+export interface McpServerInfo {
+    name?: string;
+    version?: string;
+    protocolVersion: string;
+}
+export declare class McpClientError extends Error {
+    readonly code: "mcp_server_unreachable" | "mcp_server_auth_failed" | "mcp_server_error" | "mcp_call_timeout";
+    constructor(code: "mcp_server_unreachable" | "mcp_server_auth_failed" | "mcp_server_error" | "mcp_call_timeout", message: string);
+}
+export declare class McpHttpClient {
+    private readonly fetchImpl;
+    private readonly signal;
+    private nextId;
+    private sessionId;
+    private protocolVersion;
+    constructor(options: {
+        fetch: McpFetch;
+        signal: AbortSignal;
+    });
+    private headers;
+    /** One POST. Maps transport failures and HTTP errors to McpClientError; never puts a body or header value in a message. */
+    private post;
+    private request;
+    initialize(): Promise<McpServerInfo>;
+    listTools(): Promise<McpToolEntry[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    close(): Promise<void>;
+}

package/dist/core/mcp-client/client.js

@@ -0,0 +1,141 @@
+import { readFileSync } from "node:fs";
+import { MCP_PROTOCOL_VERSION, findResponse, hasServerRequest } from "./jsonrpc.js";
+/** The package version, sent as the client version (package.json sits three levels up from src/core/mcp-client and dist/core/mcp-client). */
+const CLIENT_VERSION = JSON.parse(readFileSync(new URL("../../../package.json", import.meta.url), "utf8")).version;
+const MAX_PAGES = 20;
+const MAX_TOOLS = 500;
+const MAX_ERROR_MESSAGE_CHARS = 500;
+export class McpClientError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "McpClientError";
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export class McpHttpClient {
+    fetchImpl;
+    signal;
+    nextId = 1;
+    sessionId;
+    protocolVersion;
+    constructor(options) {
+        this.fetchImpl = options.fetch;
+        this.signal = options.signal;
+    }
+    headers() {
+        const headers = {
+            Accept: "application/json, text/event-stream",
+            "Content-Type": "application/json",
+        };
+        if (this.sessionId !== undefined)
+            headers["Mcp-Session-Id"] = this.sessionId;
+        if (this.protocolVersion !== undefined)
+            headers["MCP-Protocol-Version"] = this.protocolVersion;
+        return headers;
+    }
+    /** One POST. Maps transport failures and HTTP errors to McpClientError; never puts a body or header value in a message. */
+    async post(payload) {
+        let response;
+        try {
+            response = await this.fetchImpl({ method: "POST", headers: this.headers(), body: JSON.stringify({ jsonrpc: "2.0", ...payload }) }, this.signal);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            if (this.signal.aborted || message.startsWith("fetch_cancelled_or_timeout")) {
+                throw new McpClientError("mcp_call_timeout", "The MCP server call timed out or was cancelled.");
+            }
+            throw new McpClientError("mcp_server_unreachable", "The MCP server could not be reached.");
+        }
+        if (response.status === 401 || response.status === 403) {
+            throw new McpClientError("mcp_server_auth_failed", `The MCP server refused the credentials (HTTP ${response.status}).`);
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new McpClientError("mcp_server_error", `The MCP server answered with HTTP ${response.status}.`);
+        }
+        return response;
+    }
+    async request(method, params) {
+        const id = this.nextId++;
+        const response = await this.post({ id, method, params });
+        const contentType = response.headers["content-type"];
+        const found = findResponse(response.body, contentType, id);
+        if (found === undefined) {
+            if (hasServerRequest(response.body, contentType)) {
+                throw new McpClientError("mcp_server_error", "The MCP server asked for something Wardby doesn't support (sampling, elicitation or roots).");
+            }
+            throw new McpClientError("mcp_server_unreachable", "The MCP server sent no response to the request.");
+        }
+        // Any error member, even a malformed one ("error": null, a string), fails the call: never a TypeError.
+        const replyError = found.error;
+        if (replyError !== undefined) {
+            const text = isRecord(replyError) && typeof replyError.message === "string" ? replyError.message : "unknown error";
+            throw new McpClientError("mcp_server_error", `The MCP server returned an error: ${text.slice(0, MAX_ERROR_MESSAGE_CHARS)}`);
+        }
+        return { result: found.result, response };
+    }
+    async initialize() {
+        const { result, response } = await this.request("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: "wardby", version: CLIENT_VERSION },
+        });
+        const sessionId = response.headers["mcp-session-id"];
+        if (sessionId !== undefined && sessionId !== "")
+            this.sessionId = sessionId;
+        const body = isRecord(result) ? result : {};
+        const protocolVersion = typeof body.protocolVersion === "string" ? body.protocolVersion : MCP_PROTOCOL_VERSION;
+        this.protocolVersion = protocolVersion;
+        await this.post({ method: "notifications/initialized" });
+        const serverInfo = isRecord(body.serverInfo) ? body.serverInfo : {};
+        const info = { protocolVersion };
+        if (typeof serverInfo.name === "string")
+            info.name = serverInfo.name;
+        if (typeof serverInfo.version === "string")
+            info.version = serverInfo.version;
+        return info;
+    }
+    async listTools() {
+        const tools = [];
+        let cursor;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const { result } = await this.request("tools/list", cursor === undefined ? {} : { cursor });
+            const body = isRecord(result) ? result : {};
+            for (const entry of Array.isArray(body.tools) ? body.tools : []) {
+                if (!isRecord(entry) || typeof entry.name !== "string" || !isRecord(entry.inputSchema))
+                    continue;
+                const tool = {
+                    name: entry.name,
+                    description: typeof entry.description === "string" ? entry.description : "",
+                    inputSchema: entry.inputSchema,
+                };
+                if (isRecord(entry.annotations))
+                    tool.annotations = entry.annotations;
+                tools.push(tool);
+            }
+            if (tools.length >= MAX_TOOLS)
+                return tools.slice(0, MAX_TOOLS);
+            cursor = typeof body.nextCursor === "string" && body.nextCursor !== "" ? body.nextCursor : undefined;
+            if (cursor === undefined)
+                break;
+        }
+        return tools;
+    }
+    async callTool(name, args) {
+        const { result } = await this.request("tools/call", { name, arguments: args });
+        return result;
+    }
+    async close() {
+        if (this.sessionId === undefined)
+            return;
+        try {
+            await this.fetchImpl({ method: "DELETE", headers: this.headers() }, this.signal);
+        }
+        catch {
+            // Closing is best effort.
+        }
+    }
+}

package/dist/core/mcp-client/jsonrpc.d.ts

@@ -0,0 +1,15 @@
+/** JSON-RPC framing for MCP's Streamable HTTP transport: reads a JSON or SSE response body. */
+export declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+export interface JsonRpcResponse {
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** Finds the response to `id` in a JSON body or an SSE body. Ignores notifications and server requests. */
+export declare function findResponse(body: string, contentType: string | undefined, id: number): JsonRpcResponse | undefined;
+/** True when the body carried a server-to-client request (has `method` and `id`): we answer none of them. */
+export declare function hasServerRequest(body: string, contentType: string | undefined): boolean;

package/dist/core/mcp-client/jsonrpc.js

@@ -0,0 +1,54 @@
+/** JSON-RPC framing for MCP's Streamable HTTP transport: reads a JSON or SSE response body. */
+export const MCP_PROTOCOL_VERSION = "2025-06-18";
+/** Every JSON-RPC message in a body: a JSON value (object or batch array) or the `data:` frames of an SSE stream. */
+function messages(body, contentType) {
+    const parsed = [];
+    const isSse = (contentType ?? "").toLowerCase().includes("text/event-stream");
+    if (isSse) {
+        for (const frame of body.split(/\r?\n\r?\n/)) {
+            const data = frame
+                .split(/\r?\n/)
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => {
+                const value = line.slice(5);
+                return value.startsWith(" ") ? value.slice(1) : value;
+            });
+            if (data.length === 0)
+                continue;
+            try {
+                parsed.push(JSON.parse(data.join("\n")));
+            }
+            catch {
+                // A malformed frame is skipped.
+            }
+        }
+    }
+    else {
+        try {
+            parsed.push(JSON.parse(body));
+        }
+        catch {
+            // Not JSON: no messages.
+        }
+    }
+    const out = [];
+    for (const value of parsed) {
+        for (const item of Array.isArray(value) ? value : [value]) {
+            if (item !== null && typeof item === "object" && !Array.isArray(item))
+                out.push(item);
+        }
+    }
+    return out;
+}
+/** Finds the response to `id` in a JSON body or an SSE body. Ignores notifications and server requests. */
+export function findResponse(body, contentType, id) {
+    for (const message of messages(body, contentType)) {
+        if (message.id === id && !("method" in message))
+            return message;
+    }
+    return undefined;
+}
+/** True when the body carried a server-to-client request (has `method` and `id`): we answer none of them. */
+export function hasServerRequest(body, contentType) {
+    return messages(body, contentType).some((message) => typeof message.method === "string" && message.id !== undefined && message.id !== null);
+}

package/dist/core/mcp-client/results.d.ts

@@ -0,0 +1,13 @@
+/** Turns an MCP CallToolResult into the string the model sees. */
+export declare const MCP_RESULT_MAX_CHARS = 100000;
+export interface ToolResultText {
+    /** The text the model sees: redacted, then capped at MCP_RESULT_MAX_CHARS. */
+    text: string;
+    /** True when the server reported an error or the result was unreadable. */
+    isError: boolean;
+}
+/**
+ * The model-facing text of a CallToolResult. `redact` runs on the assembled text before it is
+ * truncated, so a secret that straddles the cut is still matched whole.
+ */
+export declare function toolResultText(result: unknown, redact?: (text: string) => string): ToolResultText;

package/dist/core/mcp-client/results.js

@@ -0,0 +1,42 @@
+/** Turns an MCP CallToolResult into the string the model sees. */
+export const MCP_RESULT_MAX_CHARS = 100_000;
+function errorText(message) {
+    return JSON.stringify({ error: "mcp_server_error", message });
+}
+function truncate(text) {
+    if (text.length <= MCP_RESULT_MAX_CHARS)
+        return text;
+    return `${text.slice(0, MCP_RESULT_MAX_CHARS)}\n[truncated: ${text.length - MCP_RESULT_MAX_CHARS} characters omitted]`;
+}
+/**
+ * The model-facing text of a CallToolResult. `redact` runs on the assembled text before it is
+ * truncated, so a secret that straddles the cut is still matched whole.
+ */
+export function toolResultText(result, redact = (t) => t) {
+    if (result === null || typeof result !== "object" || Array.isArray(result)) {
+        return { text: errorText("The MCP server returned an unreadable result."), isError: true };
+    }
+    const r = result;
+    const parts = [];
+    let hasText = false;
+    for (const part of Array.isArray(r.content) ? r.content : []) {
+        if (part === null || typeof part !== "object")
+            continue;
+        const p = part;
+        if (p.type === "text" && typeof p.text === "string") {
+            hasText = true;
+            parts.push(p.text);
+        }
+        else if (typeof p.type === "string") {
+            parts.push(`[${p.type} omitted]`);
+        }
+    }
+    let text = parts.join("\n");
+    if (!hasText && r.structuredContent !== undefined && r.structuredContent !== null) {
+        text = JSON.stringify(r.structuredContent);
+    }
+    const safe = truncate(redact(text));
+    if (r.isError === true)
+        return { text: errorText(safe), isError: true };
+    return { text: safe, isError: false };
+}

package/dist/core/mcp-servers.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Remote MCP servers: the owner-side domain. Validates a server's URL and name, loads the owner's
+ * brokered secrets for it, builds the McpFetch that sends them (brokeredFetch over safeFetch), takes
+ * the redacted tool snapshot, and diffs snapshots. Secret values never leave this file in any output:
+ * snapshots are redacted by exact value (every encoded form) plus token shapes before they are returned.
+ */
+import type { PrismaClient } from "#prisma";
+import { type McpFetch, type McpServerInfo, type McpToolEntry } from "./mcp-client/client.js";
+import type { SecretsAccessor } from "./secrets.js";
+import type { Logger } from "./logger.js";
+import type { SecretCipher } from "../providers/secrets/types.js";
+import { safeFetch } from "../sandbox/safe-fetch.js";
+export declare class McpServerInputError extends Error {
+    constructor(message: string);
+}
+/** What the server's owner (or an admin) sees when a stored secret of the server can't be decrypted. */
+export declare const CREDENTIALS_UNAVAILABLE_MESSAGE = "The MCP server's credentials can't be decrypted on this server. Check that every Wardby process (control plane, scheduler, native gateway) uses the same SECRET_APP_KEY, or set the secret again.";
+/**
+ * A server's brokered secret exists but its stored value can't be decrypted (another
+ * SECRET_APP_KEY, a key-id mismatch, a corrupt ciphertext). Not an input problem: the message is
+ * fixed and never carries the cipher's error, the ciphertext or a value.
+ */
+export declare class McpCredentialsUnavailableError extends Error {
+    /** Empty while a server is being registered (it has no id yet). */
+    readonly serverId: string;
+    readonly serverName: string;
+    readonly secretName: string;
+    readonly code = "mcp_server_credentials_unavailable";
+    constructor(
+    /** Empty while a server is being registered (it has no id yet). */
+    serverId: string, serverName: string, secretName: string);
+}
+/** The one operator line for an undecryptable server secret: ids and names only, never the cipher's error text. */
+export declare function logCredentialsUnavailable(log: Pick<Logger, "warn">, error: McpCredentialsUnavailableError): void;
+export interface McpServerRow {
+    id: string;
+    ownerId: string;
+    name: string;
+    url: string;
+    secretNames: string[];
+}
+/** Validates a server URL: https, no userinfo, no fragment, default port; returns the normalised string. */
+export declare function normaliseServerUrl(raw: string): string;
+export declare function assertServerName(name: string): void;
+/** The tool name the model sees: `<server>__<tool>` with any other character mapped to `_`. */
+export declare function exposedToolName(serverName: string, toolName: string): string;
+/** A server's saved tool list (toolSnapshot); anything but an array reads as empty. */
+export declare function snapshotOf(server: {
+    toolSnapshot: unknown;
+}): McpToolEntry[];
+/** Exposed names of allowed tools; a name too long to expose is left out (refused at attach anyway). */
+export declare function exposedNames(serverName: string, allowedTools: readonly string[]): string[];
+/** Added, removed and changed (description or schema) tool names between two snapshots; order-independent. */
+export declare function diffSnapshots(before: McpToolEntry[], after: McpToolEntry[]): {
+    added: string[];
+    removed: string[];
+    changed: string[];
+};
+/** Redacts every secret value of this server (exact, every encoded and escaped form) plus token shapes. */
+export declare function redactForServer(text: string, values: string[]): string;
+/** The same error with its message redacted; an McpClientError keeps its code, any other keeps its name. */
+export declare function redactError(error: unknown, values: string[]): Error;
+type SecretDb = Pick<PrismaClient, "secret">;
+/**
+ * Loads the owner's secrets for the server; each must exist, be owned by ownerId, be brokered, and list
+ * the URL's host (McpServerInputError otherwise). A stored value that can't be decrypted throws
+ * McpCredentialsUnavailableError.
+ */
+export declare function loadServerSecrets(db: SecretDb, cipher: Pick<SecretCipher, "decrypt">, server: McpServerRow): Promise<{
+    accessor: SecretsAccessor;
+    values: string[];
+}>;
+/** The McpFetch for one server: brokeredFetch over safeFetch with the timeout and signal; text body, lower-case headers. */
+export declare function serverFetch(server: McpServerRow, accessor: SecretsAccessor, options: {
+    timeoutMs: number;
+    fetchImpl?: typeof safeFetch;
+}): McpFetch;
+/** initialize + listTools + close; the result is redacted (as JSON text) before it is returned. */
+export declare function fetchSnapshot(server: McpServerRow, deps: {
+    db: SecretDb;
+    cipher: Pick<SecretCipher, "decrypt">;
+    fetchImpl?: typeof safeFetch;
+    timeoutMs?: number;
+}): Promise<{
+    serverInfo: McpServerInfo;
+    tools: McpToolEntry[];
+}>;
+/** For the secret delete guard: names of the owner's MCP servers whose secretNames include the secret. */
+export declare function mcpServersUsingSecret(db: Pick<PrismaClient, "mcpServer">, ownerId: string, secretName: string): Promise<string[]>;
+export {};