@wardby/cli 0.7.0 → 0.9.0

package/dist/core/mcp-tools.js

@@ -0,0 +1,287 @@
+import { ownerCanUseMcpServer } from "./grants.js";
+import { loadMcpServersMode, MCP_SERVERS_OFF_MESSAGE } from "../config/mcp-servers.js";
+import { loadToolMaxTimeoutMs } from "../config/tool-timeout.js";
+import { McpClientError, McpHttpClient } from "./mcp-client/client.js";
+import { toolResultText } from "./mcp-client/results.js";
+import { exposedToolName, loadServerSecrets, logCredentialsUnavailable, McpCredentialsUnavailableError, McpServerInputError, redactForServer, serverFetch, snapshotOf, } from "./mcp-servers.js";
+import { parseSecretBrokerConfig } from "./secret-broker-config.js";
+import { withEscapedForms } from "./secret-spans.js";
+import { consoleRedactionValues, encodedForms } from "../sandbox/secret-broker.js";
+export const DEFAULT_MCP_CALL_TIMEOUT_MS = 30_000;
+/** What a grantee's run sees when the server owner's credentials can't be loaded. */
+export const SHARED_CREDENTIALS_MESSAGE = "The MCP server's credentials can't be used; ask its owner to check it.";
+/**
+ * A Codex coding agent runs shell commands that can read the run's MCP token, so it may use only tools
+ * the server marks read-only (annotations.readOnlyHint === true in the saved tool list).
+ */
+export function isMarkedReadOnly(entry) {
+    return entry?.annotations?.readOnlyHint === true;
+}
+/**
+ * Whether a coding provider gets the Codex read-only rule. Fails closed: anything but exactly
+ * "claude-code" (Codex, an unknown value, or a coding agent with no profile) counts as Codex. A run
+ * is judged by the provider it was dispatched with (CodingRun.provider), never the agent's current
+ * profile, which can change between dispatch and launch.
+ */
+export function isCodexCoding(provider) {
+    return provider !== "claude-code";
+}
+/**
+ * Builds pins for an agent's attachments: allowed tools present in the snapshot only, from servers the
+ * agent's owner may still use (owns, or holds use on); none when the mode is off.
+ */
+export async function loadMcpToolPins(db, agentId, options = {}) {
+    if (loadMcpServersMode() === "off")
+        return [];
+    const rows = await db.agentMcpServer.findMany({
+        where: { agentId },
+        include: { server: true, agent: { select: { ownerId: true } } },
+        orderBy: [{ createdAt: "asc" }, { serverId: "asc" }],
+    });
+    const pins = [];
+    for (const row of rows) {
+        if (!(await ownerCanUseMcpServer(db, row.agent.ownerId, row.server)))
+            continue;
+        const byName = new Map(snapshotOf(row.server).map((t) => [t.name, t]));
+        for (const toolName of row.allowedTools) {
+            const entry = byName.get(toolName);
+            if (!entry)
+                continue;
+            // A refresh can drop readOnlyHint after attach: such a tool stays out of a Codex run.
+            if (options.readOnlyOnly === true && !isMarkedReadOnly(entry))
+                continue;
+            let exposedName;
+            try {
+                exposedName = exposedToolName(row.server.name, toolName);
+            }
+            catch {
+                continue;
+            }
+            pins.push({
+                exposedName,
+                toolName,
+                serverId: row.server.id,
+                serverName: row.server.name,
+                ...(row.callTimeoutMs !== null ? { callTimeoutMs: row.callTimeoutMs } : {}),
+                definition: { description: entry.description, inputSchema: entry.inputSchema },
+            });
+        }
+    }
+    return pins;
+}
+/**
+ * The pins whose exposed name no other tool of the run uses. Attach refuses clashes; this covers a
+ * name that became a built-in (or an attached tool) later: the MCP tool is left out, with a warning.
+ */
+export function withoutClashingPins(pins, otherNames, log) {
+    const taken = new Set(otherNames);
+    return pins.filter((pin) => {
+        if (!taken.has(pin.exposedName)) {
+            taken.add(pin.exposedName);
+            return true;
+        }
+        log.warn({ serverId: pin.serverId, tool: pin.toolName, exposedName: pin.exposedName }, "MCP tool left out of the run: its name clashes with another tool");
+        return false;
+    });
+}
+export function mcpToolDefs(pins) {
+    return pins.map((pin) => ({
+        name: pin.exposedName,
+        description: `From MCP server ${pin.serverName}: ${pin.definition.description}`,
+        jsonSchema: pin.definition.inputSchema,
+    }));
+}
+function error(code, message) {
+    return JSON.stringify({ error: code, message });
+}
+function parseArgs(argsJson) {
+    if (argsJson.trim() === "")
+        return {};
+    try {
+        const value = JSON.parse(argsJson);
+        return value !== null && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Never throws. Re-checks the live attachment, validates the arguments, runs initialize → tools/call →
+ * close under the time limit, and returns the redacted result text or a JSON error. One log line per call.
+ */
+export async function handleMcpTool(pin, argsJson, ctx) {
+    const startedAt = Date.now();
+    const done = (text, outcome) => {
+        ctx.log.info({
+            runId: ctx.runId,
+            agentId: ctx.agentId,
+            serverId: pin.serverId,
+            tool: pin.toolName,
+            outcome,
+            durationMs: Date.now() - startedAt,
+            resultChars: text.length,
+        }, "mcp tool call");
+        return text;
+    };
+    const fail = (code, message) => done(error(code, message), code);
+    let values = [];
+    try {
+        if (loadMcpServersMode() === "off")
+            return fail("mcp_servers_off", MCP_SERVERS_OFF_MESSAGE);
+        const row = await ctx.db.agentMcpServer.findUnique({
+            where: { agentId_serverId: { agentId: ctx.agentId, serverId: pin.serverId } },
+            include: { server: true, agent: { select: { ownerId: true } } },
+        });
+        if (!row || !row.allowedTools.includes(pin.toolName)) {
+            return fail("mcp_tool_not_allowed", `The tool "${pin.exposedName}" is no longer allowed for this agent: its MCP server was detached or the tool was taken off the allowed list.`);
+        }
+        // A revoked or lowered grant stops the very next call, even before the attachment is pruned.
+        if (!(await ownerCanUseMcpServer(ctx.db, row.agent.ownerId, row.server))) {
+            return fail("mcp_tool_not_allowed", `The tool "${pin.exposedName}" is no longer allowed for this agent: its owner no longer has use access to MCP server "${row.server.name}".`);
+        }
+        const live = snapshotOf(row.server).find((t) => t.name === pin.toolName);
+        if (!live) {
+            return fail("mcp_tool_removed", `The tool "${pin.exposedName}" is no longer in MCP server "${row.server.name}"'s tool list.`);
+        }
+        if (ctx.readOnlyOnly === true && !isMarkedReadOnly(live)) {
+            return fail("mcp_tool_not_allowed", `The tool "${pin.exposedName}" is no longer allowed for this agent: Codex agents can use only tools the server marks read-only.`);
+        }
+        const args = parseArgs(argsJson);
+        if (!args)
+            return fail("invalid_arguments", "The tool's arguments must be a JSON object.");
+        const configured = Math.min(row.callTimeoutMs ?? pin.callTimeoutMs ?? DEFAULT_MCP_CALL_TIMEOUT_MS, loadToolMaxTimeoutMs());
+        const untilDeadline = ctx.deadlineAt ? ctx.deadlineAt.getTime() - Date.now() : Infinity;
+        const limitMs = Math.max(0, Math.min(configured, untilDeadline));
+        const timedOut = `The MCP server did not answer within ${limitMs} ms.`;
+        if (ctx.signal.aborted)
+            return fail("mcp_call_timeout", "The call was stopped.");
+        if (limitMs <= 0)
+            return fail("mcp_call_timeout", "The run's time limit has been reached.");
+        const server = {
+            id: row.server.id,
+            ownerId: row.server.ownerId,
+            name: row.server.name,
+            url: row.server.url,
+            secretNames: row.server.secretNames,
+        };
+        let secrets;
+        try {
+            secrets = await loadServerSecrets(ctx.db, ctx.cipher, server);
+        }
+        catch (err) {
+            const shared = row.agent.ownerId !== server.ownerId;
+            if (err instanceof McpCredentialsUnavailableError) {
+                logCredentialsUnavailable(ctx.log, err);
+                return fail(err.code, shared ? SHARED_CREDENTIALS_MESSAGE : err.message);
+            }
+            // The detail names the server owner's secrets and speaks to that owner: a grantee's run gets neither.
+            if (err instanceof McpServerInputError && shared) {
+                return fail("mcp_server_error", SHARED_CREDENTIALS_MESSAGE);
+            }
+            throw err;
+        }
+        values = secrets.values;
+        const controller = new AbortController();
+        let stopped = false;
+        const onStop = () => {
+            stopped = true;
+            controller.abort();
+        };
+        ctx.signal.addEventListener("abort", onStop, { once: true });
+        const timer = setTimeout(() => controller.abort(), limitMs);
+        // The race ends the call even if a transport ignores the signal.
+        const aborted = new Promise((_resolve, reject) => {
+            controller.signal.addEventListener("abort", () => reject(new McpClientError("mcp_call_timeout", "aborted")), {
+                once: true,
+            });
+        });
+        aborted.catch(() => { });
+        // A stop that fired while the secrets were loading came before the listener; act on it now.
+        if (ctx.signal.aborted)
+            onStop();
+        const client = new McpHttpClient({
+            fetch: serverFetch(server, secrets.accessor, { timeoutMs: limitMs, fetchImpl: ctx.fetchImpl }),
+            signal: controller.signal,
+        });
+        try {
+            const result = await Promise.race([
+                (async () => {
+                    await client.initialize();
+                    return client.callTool(pin.toolName, args);
+                })(),
+                aborted,
+            ]);
+            const { text, isError } = toolResultText(result, (raw) => redactForServer(raw, values));
+            return done(text, isError ? "mcp_server_error" : "ok");
+        }
+        catch (err) {
+            if (controller.signal.aborted) {
+                return fail("mcp_call_timeout", stopped ? "The call was stopped." : timedOut);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+            ctx.signal.removeEventListener("abort", onStop);
+            // Best effort; never waits on a server that already ran out of time.
+            if (controller.signal.aborted)
+                void client.close().catch(() => { });
+            else
+                await client.close().catch(() => { });
+        }
+    }
+    catch (err) {
+        const message = redactForServer(err instanceof Error ? err.message : "The MCP server call failed.", values);
+        if (err instanceof McpClientError)
+            return fail(err.code, message);
+        if (err instanceof McpServerInputError)
+            return fail("mcp_server_error", message);
+        return fail("mcp_server_unreachable", "The MCP server could not be reached.");
+    }
+}
+/**
+ * Every secret value of every server attached to the agent, named `mcp:<server>/<secret>`, in
+ * every form the server's own redaction looks for. A secret that no longer exists has no value to
+ * leak and is skipped; a read that fails rejects (callers fail closed).
+ */
+export async function mcpNamedSecretValues(db, cipher, agentId) {
+    const rows = await db.agentMcpServer.findMany({
+        where: { agentId },
+        select: { server: { select: { name: true, ownerId: true, secretNames: true } } },
+    });
+    const named = [];
+    for (const { server } of rows) {
+        for (const secretName of server.secretNames) {
+            const stored = await db.secret.findUnique({
+                where: { ownerId_name: { ownerId: server.ownerId, name: secretName } },
+                select: { ciphertext: true, broker: true },
+            });
+            if (!stored)
+                continue;
+            const value = await cipher.decrypt(stored.ciphertext);
+            const base = consoleRedactionValues({ value, broker: readableBroker(stored.broker) });
+            named.push({
+                name: `mcp:${server.name}/${secretName}`,
+                values: withEscapedForms([...new Set([...base, ...base.flatMap(encodedForms)])]),
+            });
+        }
+    }
+    return named;
+}
+/** A stored broker config, or null when there is none or it cannot be read (the value alone is then redacted). */
+function readableBroker(stored) {
+    if (stored === null || stored === undefined)
+        return null;
+    try {
+        return parseSecretBrokerConfig(stored);
+    }
+    catch {
+        return null;
+    }
+}
+/** Secret values for every attached server of this agent (for run-text masking and gateway cause checks). */
+export async function mcpSecretValuesForAgent(db, cipher, agentId) {
+    return (await mcpNamedSecretValues(db, cipher, agentId)).flatMap((n) => n.values);
+}

package/dist/core/merge-order-check.js

@@ -1,4 +1,4 @@
-import { CODING_CODE_PROVIDER, normalizeGitHubRepository } from "../coding/protocol.js";
+import { codeProviderOf, normalizeHostedRepository, pullRequestWebUrl } from "../coding/code-host.js";
 import { logger } from "./logger.js";
 import { maybeMarkReady } from "./mark-ready.js";
 import { collectRelatedPullRequests, runTreeRoot } from "./related-pull-requests.js";
@@ -31,18 +31,31 @@ export function mergeOrderVerdict(self, set) {
         return { status: "in_progress", waitingFor };
     return { status: "success", dependencies };
 }
-const prUrl = (repository, number) => `https://github.com/${repository}/pull/${number}`;
-/** `repository#number` as a link: never a title or any other free text from the host. */
-const prLink = (m) => `[${m.repository}#${m.number}](${prUrl(m.repository, m.number)})`;
+/** `repository#number`, as a link when the host has one: never a title or any other free text from the host. */
+const prLink = (m) => {
+    const label = `${m.repository}#${m.number}`;
+    const url = pullRequestWebUrl(codeProviderOf(m.repository), m.repository, m.number);
+    return url ? `[${label}](${url})` : label;
+};
 const keyOf = (repository, number) => `${repository}#${number}`;
 function safeRepository(value) {
     try {
-        return normalizeGitHubRepository(value);
+        return normalizeHostedRepository(value);
     }
     catch {
         return undefined;
     }
 }
+const canPostCheck = (host) => host?.upsertNamedCheck !== undefined && host.pullRequestOrigin !== undefined;
+/** The host that can post this repository's merge order check, if any. */
+function checkHost(hosts, repository) {
+    const host = hosts?.[codeProviderOf(repository)];
+    return canPostCheck(host) ? host : undefined;
+}
+/** Whether any configured host can post the check; none means nothing to read or sync. */
+function anyCheckHost(hosts) {
+    return Object.values(hosts ?? {}).some(canPostCheck);
+}
 function originState(origin) {
     if (origin.merged)
         return "merged";
@@ -109,8 +122,7 @@ export function mergeOrderCheckInput(self, verdict, steps, headSha, leadRunning
  */
 export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
     const log = deps.log ?? moduleLog;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
+    if (!anyCheckHost(deps.hosts))
         return;
     try {
         const group = await collectRelatedPullRequests(deps.db, seedRunId);
@@ -154,9 +166,15 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
                 continue;
             }
             try {
-                const origin = reused && key === keyOf(reused, opts.origin.number)
-                    ? await opts.origin.read()
-                    : await host.pullRequestOrigin(pr.repository, pr.number);
+                let origin;
+                // Reading only needs the read: a host that can't post checks still reports its pull requests.
+                const memberHost = deps.hosts?.[codeProviderOf(pr.repository)];
+                if (reused && key === keyOf(reused, opts.origin.number))
+                    origin = await opts.origin.read();
+                else if (memberHost?.pullRequestOrigin)
+                    origin = await memberHost.pullRequestOrigin(pr.repository, pr.number);
+                else
+                    throw new Error("no_host_for_repository");
                 let headSha;
                 if (origin.markerRunId) {
                     const opener = await deps.db.codingRun.findUnique({
@@ -186,9 +204,12 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
             const verdict = mergeOrderVerdict(self, set);
             if (verdict.status === "skip")
                 continue;
+            const selfHost = checkHost(deps.hosts, self.repository);
+            if (!selfHost)
+                continue;
             const input = mergeOrderCheckInput(self, verdict, steps, target.headSha, leadRunning);
             try {
-                await host.upsertNamedCheck(self.repository, input);
+                await selfHost.upsertNamedCheck(self.repository, input);
                 log.info({ seedRunId, repository: self.repository, number: self.number, status: verdict.status }, "merge order check posted");
             }
             catch (err) {
@@ -197,7 +218,7 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
             }
             if (input.status === "completed" && input.conclusion === "success") {
                 // The last earlier step merged: the pull request may now be ready for review (#287).
-                await maybeMarkReady({ db: deps.db, hosts: deps.hosts, log: deps.log }, self.repository, self.number);
+                await maybeMarkReady({ db: deps.db, hosts: deps.hosts, log: deps.log }, self.repository, self.number, codeProviderOf(self.repository));
             }
         }
     }
@@ -212,8 +233,7 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
 export async function syncMergeOrderChecksAfterRun(deps, run) {
     if (run.parentRunId !== null)
         return;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
+    if (!anyCheckHost(deps.hosts))
         return;
     try {
         if (!(await deps.db.run.findFirst({ where: { parentRunId: run.id }, select: { id: true } })))
@@ -250,12 +270,12 @@ async function orderedSeeds(db, repository, number) {
  */
 export async function syncMergeOrderChecksForPullRequest(deps, pr, opts = {}) {
     const log = deps.log ?? moduleLog;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
-        return;
     const repository = safeRepository(pr.repository);
     if (!repository || !Number.isSafeInteger(pr.number) || pr.number <= 0)
         return;
+    // This pull request's own host need not post checks: its siblings' checks may depend on it.
+    if (!anyCheckHost(deps.hosts))
+        return;
     let roots;
     try {
         roots = [];
@@ -297,8 +317,7 @@ export function resetMergeOrderSweepForTests() {
  */
 export async function sweepMergeOrderChecks(deps, now = new Date()) {
     const log = deps.log ?? moduleLog;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
+    if (!anyCheckHost(deps.hosts))
         return 0;
     if (now.getTime() - lastSweepAt < MERGE_ORDER_SWEEP_INTERVAL_MS)
         return 0;

package/dist/core/notification-dispatcher.js

@@ -34,6 +34,7 @@
  */
 import { Prisma } from "#prisma";
 import { ChatError, } from "../providers/chat/types.js";
+import { pullRequestWebUrl } from "../coding/code-host.js";
 import { tryAcquireLease } from "./lease.js";
 import { logger } from "./logger.js";
 import { broadcasts, nextStatus, renderEvent, renderParent, senderName, } from "./notification-templates.js";
@@ -82,7 +83,7 @@ async function subjectOf(db, d) {
         return { label: ev.workItemKey, title: item?.title ?? null, url: item?.url ?? null };
     }
     if (ev.repository && ev.prNumber != null) {
-        const url = ev.codeProvider === "github" ? `https://github.com/${ev.repository}/pull/${ev.prNumber}` : null;
+        const url = pullRequestWebUrl(ev.codeProvider ?? "", ev.repository, ev.prNumber);
         return { label: `${ev.repository}#${ev.prNumber}`, title: null, url };
     }
     if (ev.runId)

package/dist/core/power-idle.d.ts

@@ -2,7 +2,9 @@
  * Low-power mode's idle rules: whether the coding proxy or native gateway has
  * had work since `since`. A target is busy while any of its runs is pending
  * (queued included) or running, or finished at or after `since`; the gateway
- * is also busy while any gateway session is active. powerBlockers lists the
+ * is also busy while any gateway session is active. The gateway's runs are
+ * sandboxed native runs plus coding runs with MCP tools: a coding run's MCP
+ * calls go coding proxy -> gateway, so it needs both. powerBlockers lists the
  * run ids that keep a target busy right now (recent finishes do not count).
  */
 import type { PrismaClient } from "#prisma";
@@ -10,5 +12,9 @@ import type { PowerTarget } from "./power.js";
 export declare function proxyBusy(db: PrismaClient, since: Date): Promise<boolean>;
 export declare function gatewayBusy(db: PrismaClient, since: Date): Promise<boolean>;
 export declare function powerBusy(db: PrismaClient): (target: PowerTarget, since: Date) => Promise<boolean>;
-/** Run ids keeping `target` busy right now: active or queued runs (plus active gateway sessions for the gateway). */
+/**
+ * Run ids keeping `target` busy right now: active or queued runs (plus, for the gateway, active
+ * gateway sessions and active or queued coding runs with MCP tools). "Active" for a coding run is
+ * the proxy's rule: its run is pending or running.
+ */
 export declare function powerBlockers(db: PrismaClient, target: PowerTarget): Promise<string[]>;

package/dist/core/power-idle.js

@@ -1,4 +1,6 @@
 const ACTIVE = { in: ["pending", "running"] };
+/** A coding run whose proxy session holds an MCP token: it has MCP tools, served through the gateway. */
+const WITH_MCP_TOOLS = { proxySession: { is: { mcpTokenHash: { not: null } } } };
 export async function proxyBusy(db, since) {
     const n = await db.codingRun.count({
         where: { run: { OR: [{ status: ACTIVE }, { finishedAt: { gte: since } }] } },
@@ -11,20 +13,32 @@ export async function gatewayBusy(db, since) {
     });
     if (runs > 0)
         return true;
+    const mcpCodingRuns = await db.codingRun.count({
+        where: { ...WITH_MCP_TOOLS, run: { OR: [{ status: ACTIVE }, { finishedAt: { gte: since } }] } },
+    });
+    if (mcpCodingRuns > 0)
+        return true;
     return (await db.nativeGatewaySession.count({ where: { status: "active" } })) > 0;
 }
 export function powerBusy(db) {
     return (target, since) => (target === "proxy" ? proxyBusy(db, since) : gatewayBusy(db, since));
 }
-/** Run ids keeping `target` busy right now: active or queued runs (plus active gateway sessions for the gateway). */
+/**
+ * Run ids keeping `target` busy right now: active or queued runs (plus, for the gateway, active
+ * gateway sessions and active or queued coding runs with MCP tools). "Active" for a coding run is
+ * the proxy's rule: its run is pending or running.
+ */
 export async function powerBlockers(db, target) {
     if (target === "proxy") {
         const rows = await db.codingRun.findMany({ where: { run: { status: ACTIVE } }, select: { runId: true } });
         return [...new Set(rows.map((r) => r.runId))].sort();
     }
-    const [runs, sessions] = await Promise.all([
+    const [runs, sessions, mcpCodingRuns] = await Promise.all([
         db.run.findMany({ where: { nativeExecutionMode: "sandbox", status: ACTIVE }, select: { id: true } }),
         db.nativeGatewaySession.findMany({ where: { status: "active" }, select: { runId: true } }),
+        db.codingRun.findMany({ where: { ...WITH_MCP_TOOLS, run: { status: ACTIVE } }, select: { runId: true } }),
     ]);
-    return [...new Set([...runs.map((r) => r.id), ...sessions.map((s) => s.runId)])].sort();
+    return [
+        ...new Set([...runs.map((r) => r.id), ...sessions.map((s) => s.runId), ...mcpCodingRuns.map((r) => r.runId)]),
+    ].sort();
 }

package/dist/core/power.d.ts

@@ -4,6 +4,11 @@ export type PowerTarget = "proxy" | "gateway";
 export declare const LOW_POWER_WAKE_TIMEOUT = "low_power_wake_timeout";
 export declare const LOW_POWER_SCALE_FORBIDDEN = "low_power_scale_forbidden";
 export declare const LOW_POWER_DISABLED = "low_power_disabled";
+/**
+ * A coding run with MCP tools could not wake the native gateway that serves them: the run fails
+ * before its worker launches (category mcp_gateway_unavailable).
+ */
+export declare const CODING_MCP_GATEWAY_UNAVAILABLE = "coding_mcp_gateway_unavailable";
 /** ISO-8601 time the control plane last scaled the Deployment up from zero. */
 export declare const POWER_WOKE_AT = "wardby.io/power-woke-at";
 /**

package/dist/core/power.js

@@ -4,6 +4,11 @@ const powerLog = logger.child({ module: "power" });
 export const LOW_POWER_WAKE_TIMEOUT = "low_power_wake_timeout";
 export const LOW_POWER_SCALE_FORBIDDEN = "low_power_scale_forbidden";
 export const LOW_POWER_DISABLED = "low_power_disabled";
+/**
+ * A coding run with MCP tools could not wake the native gateway that serves them: the run fails
+ * before its worker launches (category mcp_gateway_unavailable).
+ */
+export const CODING_MCP_GATEWAY_UNAVAILABLE = "coding_mcp_gateway_unavailable";
 /** ISO-8601 time the control plane last scaled the Deployment up from zero. */
 export const POWER_WOKE_AT = "wardby.io/power-woke-at";
 /**

package/dist/core/related-pull-requests.js

@@ -23,7 +23,7 @@
  * brings every later follow-up tree that continued one of its pull requests.
  */
 import { Prisma } from "#prisma";
-import { CODING_CODE_PROVIDER, normalizeGitHubRepository } from "../coding/protocol.js";
+import { codeProviderOf, normalizeHostedRepository, pullRequestWebUrl } from "../coding/code-host.js";
 import { issueReference, } from "../providers/issue-tracker/types.js";
 import { renderRelatedSection } from "../providers/vcs/github.js";
 import { pullRequestOutcome } from "./host-status.js";
@@ -91,7 +91,7 @@ export async function runTreeRoot(db, markerRunId, repository) {
 }
 function safeRepository(value) {
     try {
-        return normalizeGitHubRepository(value);
+        return normalizeHostedRepository(value);
     }
     catch {
         return undefined;
@@ -222,7 +222,8 @@ onlyIssueKey) {
     if (issueFilter.size > 0) {
         const recorded = await db.issuePullRequest.findMany({
             where: {
-                codeProvider: CODING_CODE_PROVIDER,
+                // A local repository has no pull requests to record: everything here is on a code host.
+                codeProvider: { not: "local" },
                 OR: [...issueFilter.values()].map((i) => ({ issueProvider: i.provider, issueKey: i.key })),
             },
             select: { repository: true, number: true, createdAt: true, openedByRunId: true, state: true },
@@ -269,6 +270,7 @@ onlyIssueKey) {
         ...(roots.size > 0 ? { roots: [...roots].map(([id, root]) => ({ id, ...root })) } : {}),
     };
 }
+const canEditRelatedSection = (host) => host?.replaceRelatedSection !== undefined && host.pullRequestOrigin !== undefined;
 function issueFor(group, trackers) {
     if (!group.issue)
         return undefined;
@@ -283,8 +285,12 @@ function issueFor(group, trackers) {
  * deployment recorded in that repository, are edited.
  */
 export async function updateRelatedPullRequests(db, run, hosts, trackers) {
-    const host = hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.replaceRelatedSection || !host.pullRequestOrigin)
+    // A request's pull requests may span hosts: each is read and written through its own.
+    const editorFor = (repository) => {
+        const host = hosts?.[codeProviderOf(repository)];
+        return canEditRelatedSection(host) ? host : undefined;
+    };
+    if (!Object.values(hosts ?? {}).some(canEditRelatedSection))
         return;
     try {
         // A run that delegated nothing has no request set of its own.
@@ -306,6 +312,10 @@ export async function updateRelatedPullRequests(db, run, hosts, trackers) {
                 continue;
             }
             try {
+                // Reading only needs the read: a host that can't edit the section still reports its pull requests.
+                const host = hosts?.[codeProviderOf(pr.repository)];
+                if (!host?.pullRequestOrigin)
+                    throw new Error("no_host_for_repository");
                 const origin = await host.pullRequestOrigin(pr.repository, pr.number);
                 const state = origin.merged
                     ? "merged"
@@ -358,6 +368,9 @@ export async function updateRelatedPullRequests(db, run, hosts, trackers) {
             });
             if (!block)
                 continue;
+            const host = editorFor(target.repository);
+            if (!host)
+                continue;
             try {
                 const outcome = await host.replaceRelatedSection(target.repository, target.number, {
                     expectedMarkerRunId: target.markerRunId,
@@ -381,7 +394,7 @@ const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 export const SIBLING_GUIDANCE = "Continue the pull request you were asked about, and a listed open one only when the change requires it. " +
     "Never open a new pull request in a repository that already has an open pull request listed here. Merged or " +
     "closed pull requests are not listed: a change there needs a new pull request.";
-const HINT_REPOSITORY = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+const HINT_REPOSITORY = /^(?:[a-z][a-z0-9-]{1,30}:)?[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
 /**
  * The continuation hint for a ticket (a GitHub or Jira issue) that already has
  * open wardby pull requests: one sentence per pull request (up to
@@ -396,9 +409,12 @@ export function openPullRequestHints(prs) {
         Number.isSafeInteger(p.number) &&
         p.number > 0)
         .slice(0, MAX_SIBLING_HINTS)
-        .map((p) => `This issue already has an open pull request wardby opened: ${p.repository}#${p.number} ` +
-        `(https://github.com/${p.repository}/pull/${p.number}). ` +
-        `To revise it, delegate with continuePriorRun set to exactly "${p.openedByRunId}".`);
+        .map((p) => {
+        const url = pullRequestWebUrl(codeProviderOf(p.repository), p.repository, p.number);
+        return (`This issue already has an open pull request wardby opened: ${p.repository}#${p.number}` +
+            `${url ? ` (${url})` : ""}. ` +
+            `To revise it, delegate with continuePriorRun set to exactly "${p.openedByRunId}".`);
+    });
     return lines.length > 0 ? [...lines, SIBLING_GUIDANCE].join("\n\n") : "";
 }
 /**
@@ -436,7 +452,7 @@ export async function openSiblings(db, seedRunId, exclude) {
 export async function openSiblingsForIssue(db, issue) {
     try {
         const newest = await db.issuePullRequest.findMany({
-            where: { issueProvider: issue.provider, issueKey: issue.key, codeProvider: CODING_CODE_PROVIDER },
+            where: { issueProvider: issue.provider, issueKey: issue.key, codeProvider: { not: "local" } },
             orderBy: { createdAt: "desc" },
             take: 1,
             select: { openedByRunId: true },

package/dist/core/retention-days.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reads a retention setting in whole days (1 to 3650) from the environment. An unset or blank value
+ * gives `defaultDays`; anything else out of range stops start-up, naming the variable.
+ */
+export declare function loadRetentionDays(env: NodeJS.ProcessEnv, name: string, defaultDays: number): number;

package/dist/core/retention-days.js

@@ -0,0 +1,14 @@
+/**
+ * Reads a retention setting in whole days (1 to 3650) from the environment. An unset or blank value
+ * gives `defaultDays`; anything else out of range stops start-up, naming the variable.
+ */
+export function loadRetentionDays(env, name, defaultDays) {
+    const raw = env[name]?.trim();
+    if (!raw)
+        return defaultDays;
+    const days = Number(raw);
+    if (!Number.isInteger(days) || days < 1 || days > 3650) {
+        throw new Error(`${name} must be a whole number of days from 1 to 3650.`);
+    }
+    return days;
+}