toolroll 0.9.44 → 0.9.46

package/dist/dispatch.d.ts

@@ -94,8 +94,8 @@ export declare function scopeApprovedForDispatch(store: Store, taskRef: number,
 export declare function dispatchRoleFor(store: Store, taskRef: number, now: Date): "builder" | "planner" | "scout";
 /** The first requirement this task fails, in words, or null. */
 export declare function missingCapability(store: Store, taskRef: number, dispatchRepo: string | null, now: Date): string | null;
-/** The read-side lifecycle answer. It changes nothing and grants nothing. */
-export declare function diagnoseTaskDispatch(store: Store, taskId: string, now: Date): DispatchDiagnosis | null;
+/** The read-side lifecycle answer. Project access limits dependency detail, never the readiness gate. */
+export declare function diagnoseTaskDispatch(store: Store, taskId: string, now: Date, readableRepos?: readonly string[] | null): DispatchDiagnosis | null;
 export declare function diagnosisIsDispatchable(diagnosis: DispatchDiagnosis | null): boolean;
 /** Attach the same lifecycle answer to the bounded fleet snapshot used by
  * both direct chat and the long-running mate. */

package/dist/dispatch.js

@@ -163,8 +163,8 @@ function approvedProfile(scope) {
         return null;
     return scope.approvedProfile ?? scope.profile ?? null;
 }
-/** The read-side lifecycle answer. It changes nothing and grants nothing. */
-export function diagnoseTaskDispatch(store, taskId, now) {
+/** The read-side lifecycle answer. Project access limits dependency detail, never the readiness gate. */
+export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
     const task = store.getTask(taskId);
     const ref = store.lookupRef(taskId);
     if (task === null || ref === null)
@@ -251,9 +251,13 @@ export function diagnoseTaskDispatch(store, taskId, now) {
     }
     if (local?.code === "dependency") {
         const terminal = local.blockerState === "failed" || local.blockerState === "cancelled";
+        const blockerRepo = readableRepos === null ? null : store.lookupRef(local.blockerId)?.repo;
+        const hidden = readableRepos !== null && (blockerRepo == null || !readableRepos.includes(blockerRepo));
+        const blocker = hidden ? "A task in another project" : local.blockerId;
+        const blockerTaskId = hidden ? null : local.blockerId;
         return terminal
-            ? answer("terminal-dependency", "waiting", "A required task did not finish", `${local.blockerId} ${local.blockerState === "cancelled" ? "was cancelled" : "failed"} before it finished.`, { action: "repair-dependency", blockerTaskId: local.blockerId })
-            : answer("waiting-dependency", "waiting", "Waiting for another task", `${local.blockerId} must finish before this task can start.`, { blockerTaskId: local.blockerId });
+            ? answer("terminal-dependency", "waiting", "A required task did not finish", `${blocker} ${local.blockerState === "cancelled" ? "was cancelled" : "failed"} before it finished.`, { action: "repair-dependency", blockerTaskId })
+            : answer("waiting-dependency", "waiting", "Waiting for another task", `${blocker} must finish before this task can start.`, { blockerTaskId });
     }
     const role = dispatchRoleFor(store, ref.id, now);
     const scope = store.getScope(taskId);

package/dist/export.js

@@ -29,14 +29,14 @@ import { readEmailSettings } from "./email-settings.js";
 import { SUBSCRIPTION_CAPABLE, readAuthMode } from "./keys.js";
 export const EXPORT_FORMAT = "standing-orders/export/v1";
 /** Tables that hold nothing but secrets or short-lived sign-in material, and derived search indexes. */
-const SECRET_TABLES = new Set(["web_session", "ceremony_nonce", "telegram_pairing", "slack_pair", "discord_pair", "teams_pair"]);
+const SECRET_TABLES = new Set(["web_session", "ceremony_nonce", "telegram_pairing", "slack_pair", "discord_pair", "teams_pair", "oauth_code", "oauth_refresh"]);
 const DERIVED_TABLE = /^(sqlite_|memory_search)/;
 /** Columns that hold a secret (or what stands in for one): never exported. */
 const SECRET_COLUMNS = new Set([
     "api_token.secret_hash", "lead_credential.secret_hash", "approver.credential_hash", "coordinator_credential.credential_hash", "runner.credential_hash", "invite.token_hash",
     "flow_trigger.hook_hash", "held_session.cookie", "push_subscription.endpoint", "push_subscription.p256dh", "push_subscription.auth",
     "chat_turn.credential_key", "mate_session.credential_key", "mate_turn.credential_key", "bridge_lease.push_url", "workflow_preview.token",
-    "quota.credential_fp",
+    "quota.credential_fp", "oauth_grant.renew_hash", "oauth_client.source_hash",
 ]);
 /** A column named like this holds a secret unless it is reviewed below; an unreviewed one is dropped. */
 const SECRET_NAME = /hash|secret|token|passw|cookie|csrf|credential|p256dh|^auth$|key|nonce|endpoint|url/i;
@@ -56,7 +56,7 @@ export function categoryOf(table) {
         [/^teammate/, "teammates"],
         [/^(flow|routine|workflow_)/, "flows"],
         [/^(chat_|mate_|team_|telegram_|slack_|discord_|teams_|notification|push_|bridge_lease)/, "chats"],
-        [/^(approver|api_token|lead_credential|invite|sso_identity|coordinator_)/, "people"],
+        [/^(approver|api_token|lead_credential|invite|sso_identity|coordinator_|oauth_)/, "people"],
         [/^(run|artifact|claim|worktree$|execution_slot|contest|tournament_terms|fallback_cycle|fallback_transition|held_session|session_turn|attended_authorization|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
         [/^(task|hold$|plan_|scope_|tool_seal|decision|external_|skill_test)/, "tasks"],
         [/^(project|approval_policy|capability|verify_command|worktree_setup|backend_grant|intake_grant|publication_grant|operating_mode|knowledge_|learning_|memory_|skill_)/, "projects"],
@@ -67,6 +67,7 @@ export function categoryOf(table) {
 /** Extra shapes beside the evidence scanner's: this installation's own tokens and password hashes, and bearer headers. */
 const EXTRA_SHAPES = [
     /\bso_[a-f0-9]{12}_[A-Za-z0-9_-]{43}/g,
+    /\bsor_[a-f0-9]{12}_[A-Za-z0-9_-]{43}/g,
     /\blt_[a-f0-9]{12}_[A-Za-z0-9_-]{43}/g,
     /\bscrypt\$[^\s"',;]+/g,
     /\bBearer\s+[A-Za-z0-9._~+/-]{16,}=*/gi,

package/dist/lead-status.d.ts

@@ -101,7 +101,11 @@ export declare function repairStaleStatuses(store: Store, now: Date): {
     exitsRecorded: number;
     readyForReview: number;
 };
-/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead. */
-export declare function installationStatus(store: Store, now: Date, viewer?: string | null): InstallationStatus;
-export declare function renderInstallationStatus(status: InstallationStatus): string[];
+/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead.
+ * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
+ * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
+ * the release check, plan windows and the lead line are empty, never another project's. */
+export declare function installationStatus(store: Store, now: Date, viewer?: string | null, repos?: readonly string[] | null): InstallationStatus;
+/** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
+export declare function renderInstallationStatus(status: InstallationStatus, limited?: boolean): string[];
 export declare function renderTaskWait(snapshot: TaskWaitSnapshot, outcome?: string): string;

package/dist/lead-status.js

@@ -181,15 +181,20 @@ export function repairStaleStatuses(store, now) {
     const exitsRecorded = store.recordFinishedRunExits(now);
     return { exitsRecorded, readyForReview: workReadyForReview(store, now, { principal: "operator", repos: null, includeUnplaced: true }, 0).count };
 }
-/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead. */
-export function installationStatus(store, now, viewer = currentActor()?.account ?? null) {
-    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task
+/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead.
+ * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
+ * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
+ * the release check, plan windows and the lead line are empty, never another project's. */
+export function installationStatus(store, now, viewer = currentActor()?.account ?? null, repos = null) {
+    const admitted = (row) => repos === null || typeof row["repo"] === "string" && repos.includes(row["repo"]);
+    const access = { principal: "operator", repos, includeUnplaced: repos === null };
+    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task, ref.repo
     FROM run INDEXED BY work_unfinished
     JOIN task_ref AS ref ON ref.id = run.task_ref
     JOIN claim ON claim.lease_id = run.lease_id
     WHERE run.outcome IS NULL AND claim.released_at IS NULL AND claim.expires_at > ?
       AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest INDEXED BY claim_by_task WHERE newest.task_ref = run.task_ref)
-    ORDER BY run.id`).all(now.toISOString());
+    ORDER BY run.id`).all(now.toISOString()).filter(admitted);
     const phases = new Map();
     const runningTasks = runningRows.map(row => {
         const phase = phaseWords(phaseOf(row));
@@ -197,7 +202,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         return { task: String(row["task"]), run: Number(row["id"]), phase };
     });
     const runningRefs = new Set(runningRows.map(row => Number(row["task_ref"])));
-    const queuedRows = store.handle.prepare(`SELECT task.id, ref.id AS task_ref, ref.plan, ref.strikes, scope.digest AS scope_digest,
+    const queuedRows = store.handle.prepare(`SELECT task.id, ref.id AS task_ref, ref.repo, ref.plan, ref.strikes, scope.digest AS scope_digest,
       scope.profile_state,
       (scope.approved_at IS NOT NULL AND scope.approved_by IS NOT NULL AND scope.approved_digest = scope.digest) AS approved,
       EXISTS (SELECT 1 FROM task_edge WHERE task_edge.blocked = task.id
@@ -208,7 +213,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
     JOIN task_ref AS ref INDEXED BY sqlite_autoindex_task_ref_1 ON ref.backend = ? AND ref.external_id = task.id
     LEFT JOIN task_scope AS scope ON scope.task_id = task.id
     WHERE task.state = 'queued'`).all(now.toISOString(), BUILT_IN)
-        .filter(row => !runningRefs.has(Number(row["task_ref"])));
+        .filter(row => !runningRefs.has(Number(row["task_ref"])) && admitted(row));
     const reasons = new Map();
     const queuedTasks = [];
     const pauses = openAuthPauses(store);
@@ -227,11 +232,11 @@ export function installationStatus(store, now, viewer = currentActor()?.account
     }
     // One per family, from the same projection as the Tasks list: a completed
     // family (root or any revision) and a superseded version never count.
-    const ready = workReadyForReview(store, now, { principal: "operator", repos: null, includeUnplaced: true }, 5);
+    const ready = workReadyForReview(store, now, access, 5);
     const checkRow = (run) => store.handle.prepare(`SELECT ${CHECK_COLUMNS} FROM run_check AS rc WHERE rc.run = ?`).get(run);
     // Run ids grow with time, so the newest finished release check is the
     // first finished row down the partial index.
-    const release = store.handle.prepare(`SELECT run.id, run.finished_at, ${CHECK_COLUMNS}, ref.external_id AS task
+    const release = repos !== null ? undefined : store.handle.prepare(`SELECT run.id, run.finished_at, ${CHECK_COLUMNS}, ref.external_id AS task
     FROM run_check AS rc INDEXED BY run_check_release
     JOIN run ON run.id = rc.run
     JOIN task_ref AS ref ON ref.id = run.task_ref
@@ -247,7 +252,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         },
         waitingForReview: { count: ready.count, results: ready.results.map(one => ({ task: one.taskId, run: one.run, check: checkOf(one.run === null ? undefined : checkRow(one.run)) })) },
         releaseCheck: release === undefined ? null : { task: String(release["task"]), run: Number(release["id"]), finishedAt: release["finished_at"] == null ? null : String(release["finished_at"]), check: checkOf(release) },
-        planWindows: store.handle.prepare(`SELECT provider, window, used_percent, window_minutes, resets_at, reached, plan, observed_at
+        planWindows: repos !== null ? [] : store.handle.prepare(`SELECT provider, window, used_percent, window_minutes, resets_at, reached, plan, observed_at
       FROM provider_limit INDEXED BY sqlite_autoindex_provider_limit_1 ORDER BY provider, window`).all().map(row => ({
             provider: String(row["provider"]),
             plan: row["plan"] == null ? null : String(row["plan"]),
@@ -259,16 +264,17 @@ export function installationStatus(store, now, viewer = currentActor()?.account
             observedAt: String(row["observed_at"]),
         })),
         signIn: pauses.map(one => ({ provider: one.provider, reason: signInReason(one), command: signInCommand(one), since: one.openedAt })),
-        tasks: workIndexPage(store, now, { principal: "operator", repos: null, includeUnplaced: true, viewer }, { limit: 8 }).items
+        tasks: workIndexPage(store, now, { ...access, viewer }, { limit: 8 }).items
             .map(one => ({ task: one.rootId, title: one.title, headline: one.status.label, sentence: one.status.detail })),
-        lead: (() => {
+        lead: repos !== null ? null : (() => {
             // Only the asker's own lead: another person's lead is never "Your lead".
             const activity = leadActivity(store, viewer);
             return activity === null ? null : { owner: activity.owner, doing: activity.doing, at: activity.at, task: activity.taskId, line: leadActivityLine(activity, now) };
         })(),
     };
 }
-export function renderInstallationStatus(status) {
+/** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
+export function renderInstallationStatus(status, limited = false) {
     const lines = [];
     // A paused provider comes first: it is the one thing a person must do.
     for (const one of status.signIn)
@@ -284,6 +290,9 @@ export function renderInstallationStatus(status) {
     lines.push(status.running.count === 0 ? "Building: none" : `Building: ${status.running.count} — ${status.running.tasks.map(one => `${one.task} (#${one.run}, ${one.phase})`).join(", ")}${status.running.count > status.running.tasks.length ? ", …" : ""}`);
     lines.push(status.queued.count === 0 ? "Queued: none" : `Queued: ${status.queued.count} — ${status.queued.tasks.map(one => `${one.task} (${one.reason})`).join(", ")}${status.queued.count > status.queued.tasks.length ? ", …" : ""}`);
     lines.push(status.waitingForReview.count === 0 ? "Ready for review: none" : `Ready for review: ${status.waitingForReview.count} — ${status.waitingForReview.results.map(one => one.run === null ? one.task : `${one.task} (#${one.run})`).join(", ")}${status.waitingForReview.count > status.waitingForReview.results.length ? ", …" : ""}`);
+    // Neither the release check nor plan windows belong to a person's projects: a limited report leaves both out.
+    if (limited)
+        return lines;
     if (status.releaseCheck === null) {
         lines.push("Release check: none recorded");
     }

package/dist/mcp-http.d.ts

@@ -11,7 +11,8 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { Store } from "./store.js";
-import { type RunOperateAs } from "./mcp-person.js";
+import { type Person, type RunOperateAs } from "./mcp-person.js";
+import { type Admission } from "./request-budget.js";
 export type McpHttpOptions = {
     store: Store;
     clock: () => Date;
@@ -20,7 +21,11 @@ export type McpHttpOptions = {
     evidenceRoot?: string;
     /** The console's own sign-in for an `so_` bearer: the address's tries, expiry, revocation, a removed account. */
     signedIn: (request: IncomingMessage) => boolean;
+    /** Where an MCP client finds how to sign in (mcp-oauth.ts), named on a 401; null when this address offers none. */
+    resourceMetadata?: (request: IncomingMessage) => string | null;
     /** Runs a person's command on the server (operate.ts); resolved from operate.ts when not injected. */
     runAs?: RunOperateAs;
+    /** A person token's request budget (request-budget.ts), charged once per request before its body is read. */
+    admit?: (person: Person) => Admission;
 };
 export declare function createMcpHttp(options: McpHttpOptions): (request: IncomingMessage, response: ServerResponse) => Promise<void>;

package/dist/mcp-http.js

@@ -10,10 +10,12 @@
  * Host check runs before this route. A revoked or expired token answers 401 on its next request.
  */
 import { PACKAGE_VERSION } from "./version.js";
-import { parseApiToken, secretMatches } from "./api-tokens.js";
+import { parseApiToken, secretMatches, tokenLive, tokenProjects } from "./api-tokens.js";
+import { oauthProjects, oauthTokenAllowed, RESOURCE_PATH } from "./mcp-oauth.js";
 import { authenticateCoordinator } from "./coordinator.js";
 import { LEGACY, MAX_REQUEST, META_CAPABILITIES, META_SERVER, META_VERSION, MODERN, TOOLS, UNSUPPORTED_VERSION, callCoordinatorTool, capabilitiesShape, readMessage, shapeResult, toolsPayload, } from "./mcp-core.js";
 import { callPersonTool, personTools } from "./mcp-person.js";
+import { limitWords } from "./request-budget.js";
 /** The most decisions a coordinator credential is remembered to have read (propose_answer needs one). */
 const READ_DECISIONS_KEPT = 200;
 export function createMcpHttp(options) {
@@ -38,15 +40,20 @@ export function createMcpHttp(options) {
             // The secret is checked here too, so this door never rests on how signedIn reads the request.
             if (parsed === null || kept === null || !secretMatches(parsed.secret, kept.secretHash))
                 return null;
-            if (kept.row.revokedAt !== null || Date.parse(kept.row.expiresAt) <= options.clock().getTime())
+            if (!tokenLive(kept.row, options.clock().getTime()))
                 return null;
             const account = store.accountOf(kept.row.account);
             if (account === null || account.revokedAt !== null)
                 return null;
+            // An MCP sign-in's token: only while its access is fresh, and only in the projects the person chose (mcp-oauth.ts).
+            if (!oauthTokenAllowed(store, kept.row.id, RESOURCE_PATH, options.clock()))
+                return null;
+            const granted = oauthProjects(store, kept.row.id);
+            const projects = tokenProjects(tokenProjects(account.projects, kept.row.projects), granted);
             return {
                 kind: "person",
                 person: {
-                    principal: { kind: "person", account: kept.row.account, generation: account.generation, scope: kept.row.access, tokenId: kept.row.id, projects: account.projects === null ? null : [...account.projects] },
+                    principal: { kind: "person", account: kept.row.account, generation: account.generation, scope: kept.row.access, tokenId: kept.row.id, projects },
                     role: account.role,
                     tokenName: kept.row.name,
                 },
@@ -100,7 +107,18 @@ export function createMcpHttp(options) {
             return refuse(response, 403, "browser requests are refused — connect an MCP client with your API token");
         const caller = callerOf(request);
         if (caller === null) {
-            return refuse(response, 401, "sign in with your API token (Authorization: Bearer so_…) or a coordinator credential — passwords and cookies are not accepted here", { "www-authenticate": 'Bearer realm="toolroll-mcp"' });
+            const metadata = options.resourceMetadata?.(request) ?? null;
+            return refuse(response, 401, "sign in with your API token (Authorization: Bearer so_…) or a coordinator credential — passwords and cookies are not accepted here", { "www-authenticate": `Bearer realm="toolroll-mcp"${metadata === null ? "" : `, resource_metadata="${metadata}"`}` });
+        }
+        // A person's token is counted once per request, notifications included; a coordinator keeps its own proposal limit.
+        if (caller.kind === "person" && options.admit !== undefined) {
+            const admitted = options.admit(caller.person);
+            if (!admitted.ok && admitted.status === 503)
+                return refuse(response, 503, "request limits could not be checked; nothing ran — try again shortly");
+            if (!admitted.ok) {
+                request.resume();
+                return send(response, 429, { jsonrpc: "2.0", id: null, error: { code: -32000, message: limitWords(admitted.limit, admitted.retryAfter), data: { limit: admitted.limit, retryAfter: admitted.retryAfter } } }, { "retry-after": String(admitted.retryAfter) });
+            }
         }
         if (!/^application\/json\s*(;|$)/i.test(request.headers["content-type"] ?? ""))
             return refuse(response, 415, "send the JSON-RPC message as application/json");

package/dist/mcp-oauth.d.ts

@@ -0,0 +1,82 @@
+/**
+ * MCP sign-in: OAuth 2.1 for /mcp, as the MCP authorization spec describes, so an engineer's MCP client connects
+ * without a pasted token. This console is both the authorization server and the protected resource.
+ *
+ *   /mcp's 401 names /.well-known/oauth-protected-resource/mcp (RFC 9728), which names this console's
+ *   /.well-known/oauth-authorization-server (RFC 8414). A client registers itself (RFC 7591, public clients only),
+ *   sends the person to /oauth/authorize with a S256 PKCE challenge and resource=<origin>/mcp, and trades the code
+ *   at /oauth/token for a short-lived access token and a refresh secret that rotates on every use.
+ *
+ * The person signs in with the console's own sign-in (password or identity provider, unchanged), then consents on
+ * one page: read or act, and which of their projects, confirmed with their password or a fresh provider check, the
+ * same step-up as making an API token. Nothing is granted without that form, its session CSRF value and a same-site
+ * post.
+ *
+ * A grant is an ordinary API token (api-tokens.ts): its access token is `so_<id>_<secret>`, it is listed and revoked
+ * with every other token (console Sessions & tokens, `toolroll tokens`), and /mcp runs it through the same person
+ * path. Its v113 binding (store.oauthGrant) adds what an ordinary token doesn't have: it works only at /mcp, its
+ * access secret lasts an hour, it is tied to the account generation that consented, and it reaches only the projects
+ * chosen (still intersected with the person's live access on every call). Only hashes are kept: of codes, access
+ * secrets and refresh secrets. Approvals, people and policy are never reachable: those have no tool and no scope.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Store } from "./store.js";
+/** How long each piece lives. A code is spent at once; a grant ends after 30 days and the person consents again. */
+export declare const OAUTH_TIMES: {
+    readonly requestMs: number;
+    readonly codeMs: 60000;
+    readonly accessSeconds: 3600;
+    readonly grantDays: 30;
+};
+/** The most sign-ins waiting at once, and registered clients kept. */
+export declare const OAUTH_LIMITS: {
+    readonly requests: 200;
+    readonly requestsPerSource: 20;
+    readonly clients: 500;
+    readonly clientsPerSource: 20;
+};
+export declare const OAUTH_SCOPES: readonly ["read", "act"];
+export declare const RESOURCE_PATH = "/mcp";
+export declare const resourceMetadataUrl: (origin: string) => string;
+/**
+ * Whether an API token may sign in to this request's path now. An ordinary token: yes (its own checks are elsewhere).
+ * An MCP sign-in's token: only at /mcp, only while its access secret is fresh and the account is at the generation
+ * that consented.
+ */
+export declare function oauthTokenAllowed(store: Store, tokenId: string, path: string, now: Date): boolean;
+/** The projects an MCP sign-in's token was granted (the person's live access still applies), or null for an ordinary token. */
+export declare const oauthProjects: (store: Store, tokenId: string) => string[] | null;
+export type OAuthSession = {
+    name: string;
+    role: "approver" | "viewer";
+    csrf: string;
+    /** Signed in with an identity provider: its name, and whether it checked the person in the last ten minutes. */
+    sso: {
+        label: string;
+        fresh: boolean;
+    } | null;
+};
+export type OAuthHttpOptions = {
+    store: Store;
+    clock: () => Date;
+    /** This console's canonical origin for the request (the https public address, or this computer's loopback one); null: no sign-in here. */
+    originOf: (request: IncomingMessage) => string | null;
+    /** Trusted direct peer, or the last hop appended by the console's loopback proxy. */
+    requesterKey: (request: IncomingMessage) => string;
+    /** The browser session signed in by cookie, or null. A bearer never consents. */
+    session: (request: IncomingMessage) => OAuthSession | null;
+    /** A posted form came from a page of this console (its Origin, or Referer, names an allowed host). */
+    sameSite: (request: IncomingMessage) => boolean;
+    /** The step-up: the person's password, or (empty) a fresh identity-provider check. */
+    confirm: (session: OAuthSession, typed: string) => boolean;
+    /** The projects this person may choose: each a project the server knows that they can use now. */
+    projectsFor: (account: string) => string[];
+};
+/**
+ * A redirect a client may register: https anywhere, or http on 127.0.0.1 / [::1] (RFC 8252 §7.3), with no
+ * credentials or fragment.
+ */
+export declare function redirectAllowed(value: string): boolean;
+/** A redirect matches a registered one exactly; on a loopback http address any port does (RFC 8252 §7.3). */
+export declare function redirectMatches(presented: string, registered: readonly string[]): string | null;
+export declare function createOAuthHttp(options: OAuthHttpOptions): (request: IncomingMessage, response: ServerResponse, url: URL) => Promise<boolean>;