oma-coding-agent 1.1.4

package/src/modes/internal-url-autocomplete.ts

@@ -0,0 +1,143 @@
+/**
+ * Autocomplete for internal-url schemes (skill://, rule://, omp://, local://,
+ * memory://, agent://, artifact://) while composing a prompt.
+ *
+ * Detection here MUST stay in sync with the generic URL-scheme trigger in the
+ * TUI editor (`packages/tui/src/components/editor.ts`); the editor fires the
+ * popup, this module decides whether there are candidates to show.
+ */
+import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
+import { InternalUrlRouter } from "../internal-urls/router";
+
+/** Upper bound on candidates surfaced in the dropdown. */
+const MAX_URL_SUGGESTIONS = 25;
+
+/**
+ * A URL token ending at the cursor: a known internal scheme followed by one or
+ * two slashes and the partially typed host/path. The boundary/rest character
+ * classes mirror the editor trigger so both agree on what counts as a token.
+ */
+const URL_TOKEN_RE = /(?:^|[\s"'`(<=])([a-z][a-z0-9+.-]*:\/{1,2}[^\s"'`()<>]*)$/i;
+const SCHEME_SPLIT_RE = /^([a-z][a-z0-9+.-]*):\/{1,2}(.*)$/i;
+
+export interface InternalUrlContext {
+	/** Lowercased scheme (e.g. `local`). */
+	scheme: string;
+	/** Text typed after the slashes so far (host + path); may be empty. */
+	query: string;
+	/** Exact buffer token from its boundary to the cursor (the completion prefix). */
+	token: string;
+}
+
+// Subsequence fuzzy match: `hum` matches `humanizer`, `lp` matches `local-plan`.
+function fuzzyMatch(query: string, target: string): boolean {
+	if (query.length === 0) return true;
+	if (query.length > target.length) return false;
+	let q = 0;
+	for (let t = 0; t < target.length && q < query.length; t += 1) {
+		if (query[q] === target[t]) q += 1;
+	}
+	return q === query.length;
+}
+
+// Higher is better: exact > prefix > substring > scattered subsequence.
+function fuzzyScore(query: string, target: string): number {
+	if (query.length === 0) return 1;
+	if (target === query) return 100;
+	if (target.startsWith(query)) return 80;
+	if (target.includes(query)) return 60;
+	let q = 0;
+	let gaps = 0;
+	let last = -1;
+	for (let t = 0; t < target.length && q < query.length; t += 1) {
+		if (query[q] === target[t]) {
+			if (last >= 0 && t - last > 1) gaps += 1;
+			last = t;
+			q += 1;
+		}
+	}
+	if (q !== query.length) return 0;
+	return Math.max(1, 40 - gaps * 5);
+}
+
+/**
+ * Detect a completable internal-url token immediately before the cursor.
+ * Returns `null` when the text is not a `scheme://` token whose scheme is
+ * registered with a completion-capable handler.
+ */
+export function extractInternalUrlContext(textBeforeCursor: string): InternalUrlContext | null {
+	const tokenMatch = URL_TOKEN_RE.exec(textBeforeCursor);
+	if (!tokenMatch) return null;
+	const token = tokenMatch[1]!;
+	const parts = SCHEME_SPLIT_RE.exec(token);
+	if (!parts) return null;
+	const scheme = parts[1]!.toLowerCase();
+	if (!InternalUrlRouter.instance().completionSchemes().includes(scheme)) return null;
+	return { scheme, query: parts[2] ?? "", token };
+}
+
+/**
+ * Suggestions for the internal-url token ending at the cursor, or `null` when
+ * the text is not such a token or no candidate matches the typed query.
+ */
+export async function getInternalUrlSuggestions(
+	textBeforeCursor: string,
+): Promise<{ items: AutocompleteItem[]; prefix: string } | null> {
+	const ctx = extractInternalUrlContext(textBeforeCursor);
+	if (!ctx) return null;
+
+	const candidates = await InternalUrlRouter.instance().complete(ctx.scheme, ctx.query);
+	if (!candidates || candidates.length === 0) return null;
+
+	const query = ctx.query.toLowerCase();
+	const scored: Array<{ item: AutocompleteItem; score: number }> = [];
+	for (const candidate of candidates) {
+		const target = candidate.value.toLowerCase();
+		if (!fuzzyMatch(query, target)) continue;
+		scored.push({
+			item: {
+				value: `${ctx.scheme}://${candidate.value}`,
+				label: candidate.label ?? candidate.value,
+				...(candidate.description ? { description: candidate.description } : {}),
+			},
+			score: fuzzyScore(query, target),
+		});
+	}
+	if (scored.length === 0) return null;
+
+	scored.sort((a, b) => b.score - a.score);
+	return {
+		items: scored.slice(0, MAX_URL_SUGGESTIONS).map(entry => entry.item),
+		prefix: ctx.token,
+	};
+}
+
+/** Whether `prefix` (the token a completion was offered for) is an internal-url token. */
+export function isInternalUrlPrefix(prefix: string): boolean {
+	return extractInternalUrlContext(prefix) !== null;
+}
+
+/**
+ * Replace the internal-url token with the selected candidate, appending a
+ * trailing space (matching `@` file-reference behavior) so the user can keep
+ * typing.
+ */
+export function applyInternalUrlCompletion(
+	lines: string[],
+	cursorLine: number,
+	cursorCol: number,
+	item: AutocompleteItem,
+	prefix: string,
+): { lines: string[]; cursorLine: number; cursorCol: number } {
+	const currentLine = lines[cursorLine] || "";
+	const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+	const afterCursor = currentLine.slice(cursorCol);
+	const insert = `${item.value} `;
+	const newLines = [...lines];
+	newLines[cursorLine] = beforePrefix + insert + afterCursor;
+	return {
+		lines: newLines,
+		cursorLine,
+		cursorCol: beforePrefix.length + insert.length,
+	};
+}

package/src/modes/loop-limit.ts

@@ -0,0 +1,192 @@
+export type LoopLimitConfig =
+	| {
+			kind: "iterations";
+			iterations: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+	  };
+
+export type LoopLimitRuntime =
+	| {
+			kind: "iterations";
+			initial: number;
+			remaining: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+			deadlineMs: number;
+	  };
+
+const TIME_UNITS_MS = new Map<string, number>([
+	["s", 1_000],
+	["sec", 1_000],
+	["secs", 1_000],
+	["second", 1_000],
+	["seconds", 1_000],
+	["m", 60_000],
+	["min", 60_000],
+	["mins", 60_000],
+	["minute", 60_000],
+	["minutes", 60_000],
+	["h", 3_600_000],
+	["hr", 3_600_000],
+	["hrs", 3_600_000],
+	["hour", 3_600_000],
+	["hours", 3_600_000],
+]);
+
+const LOOP_USAGE = "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+
+export interface ParsedLoopArgs {
+	/** Iteration/duration budget, when the user supplied a leading limit token. */
+	limit?: LoopLimitConfig;
+	/** Inline loop prompt: text after the limit, or the whole argument when no limit was given. */
+	prompt?: string;
+}
+
+/**
+ * Parse `/loop` arguments into an optional leading limit plus an optional inline
+ * prompt. A token that *looks* like a limit (starts with a digit or sign) but
+ * fails to parse is a hard error; anything else is treated as prompt text, so
+ * plain prose after `/loop` keeps starting an unbounded loop instead of erroring
+ * (the pre-arg-parsing behavior). Returns the error message string on failure.
+ */
+export function parseLoopLimitArgs(args: string): ParsedLoopArgs | string {
+	const trimmed = args.trim();
+	if (!trimmed) return {};
+
+	const firstSpace = trimmed.search(/\s/);
+	const firstToken = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+	const rest = firstSpace === -1 ? "" : trimmed.slice(firstSpace + 1).trim();
+	const token = firstToken.toLowerCase();
+
+	// Not a limit attempt (prose like "keep going") → unbounded loop, prompt = full args.
+	if (!/^[+-]?\d/.test(token)) {
+		return { prompt: trimmed };
+	}
+
+	// Bare integer: iteration count, unless the next token is a time unit ("10 minutes").
+	if (/^\d+$/.test(token)) {
+		if (rest) {
+			const restTokens = rest.split(/\s+/);
+			const unitMs = TIME_UNITS_MS.get(restTokens[0].toLowerCase());
+			if (unitMs !== undefined) {
+				const limit = makeDuration(token, unitMs);
+				if (typeof limit === "string") return limit;
+				return { limit, prompt: restTokens.slice(1).join(" ").trim() || undefined };
+			}
+		}
+		const limit = makeIterations(token);
+		if (typeof limit === "string") return limit;
+		return { limit, prompt: rest || undefined };
+	}
+
+	// Compact / compound duration: "10m", "90s", "1h30m".
+	const duration = parseCompoundDuration(token);
+	if (duration !== undefined) {
+		if (typeof duration === "string") return duration;
+		return { limit: duration, prompt: rest || undefined };
+	}
+
+	// Limit-shaped but unparseable ("-1", "1.5h", "10x10").
+	return LOOP_USAGE;
+}
+
+function makeIterations(amountText: string): LoopLimitConfig | string {
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount <= 0) {
+		return "Loop count must be a positive integer.";
+	}
+	return { kind: "iterations", iterations: amount };
+}
+
+function makeDuration(amountText: string, unitMs: number): LoopLimitConfig | string {
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount <= 0) {
+		return "Loop duration must be positive.";
+	}
+	return { kind: "duration", durationMs: amount * unitMs };
+}
+
+/**
+ * Parse a compact duration token such as `10m`, or a compound one like `1h30m`.
+ * Returns `undefined` when the token is not duration-shaped, or an error string
+ * when it is shaped like a duration but uses an unknown unit / non-positive
+ * amount.
+ */
+function parseCompoundDuration(token: string): LoopLimitConfig | string | undefined {
+	if (!/^(?:\d+[a-z]+)+$/.test(token)) return undefined;
+	const segments = token.match(/\d+[a-z]+/g);
+	if (!segments) return undefined;
+	let totalMs = 0;
+	for (const segment of segments) {
+		const match = /^(\d+)([a-z]+)$/.exec(segment);
+		if (!match) return LOOP_USAGE;
+		const unitMs = TIME_UNITS_MS.get(match[2]);
+		if (unitMs === undefined) {
+			return "Loop duration unit must be seconds, minutes, or hours.";
+		}
+		const amount = Number(match[1]);
+		if (!Number.isSafeInteger(amount) || amount <= 0) {
+			return "Loop duration must be positive.";
+		}
+		totalMs += amount * unitMs;
+	}
+	if (totalMs <= 0) return "Loop duration must be positive.";
+	return { kind: "duration", durationMs: totalMs };
+}
+
+export function createLoopLimitRuntime(
+	config: LoopLimitConfig | undefined,
+	nowMs = Date.now(),
+): LoopLimitRuntime | undefined {
+	if (!config) return undefined;
+	if (config.kind === "iterations") {
+		return { kind: "iterations", initial: config.iterations, remaining: config.iterations };
+	}
+	return { kind: "duration", durationMs: config.durationMs, deadlineMs: nowMs + config.durationMs };
+}
+
+export function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs = Date.now()): boolean {
+	if (!limit) return true;
+	if (limit.kind === "duration") {
+		return nowMs < limit.deadlineMs;
+	}
+	if (limit.remaining <= 0) return false;
+	limit.remaining -= 1;
+	return true;
+}
+
+export function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs = Date.now()): boolean {
+	return limit?.kind === "duration" && nowMs >= limit.deadlineMs;
+}
+
+export function describeLoopLimit(config: LoopLimitConfig): string {
+	if (config.kind === "iterations") {
+		return `${config.iterations} ${config.iterations === 1 ? "iteration" : "iterations"}`;
+	}
+	return formatDuration(config.durationMs);
+}
+
+export function describeLoopLimitRuntime(limit: LoopLimitRuntime): string {
+	if (limit.kind === "iterations") {
+		return `${limit.remaining} of ${limit.initial} ${limit.initial === 1 ? "iteration" : "iterations"} remaining`;
+	}
+	return `${formatDuration(limit.durationMs)} limit`;
+}
+
+function formatDuration(durationMs: number): string {
+	if (durationMs % 3_600_000 === 0) {
+		const hours = durationMs / 3_600_000;
+		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	if (durationMs % 60_000 === 0) {
+		const minutes = durationMs / 60_000;
+		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	const seconds = durationMs / 1_000;
+	return `${seconds} ${seconds === 1 ? "second" : "seconds"}`;
+}

package/src/modes/magic-keywords.ts

@@ -0,0 +1,42 @@
+import { containsOrchestrate, highlightOrchestrate } from "./orchestrate";
+import { containsUltrathink, highlightUltrathink } from "./ultrathink";
+import { containsWorkflow, highlightWorkflow } from "./workflow";
+
+/**
+ * Gradient-highlight every magic keyword ("ultrathink", "orchestrate",
+ * "workflowz") that appears as standalone prose, skipping any occurrence inside a
+ * code block, inline code span, or XML/HTML section. Each highlighter paints its
+ * own keyword with its own gradient, so chaining is order-independent — the
+ * earlier passes only inject zero-width SGR escapes (no backticks or angle
+ * brackets), which never confuse the later passes' markdown masking.
+ *
+ * `resetTo` is the SGR foreground sequence restored after each painted keyword;
+ * pass the surrounding text color when decorating already-colored content (e.g.
+ * a themed message bubble) so the gradient does not bleed into the rest of the
+ * line. Defaults to a plain foreground reset for default-colored editor text.
+ *
+ * `phase` ∈ [0, 1) cyclically rotates each gradient — the editor passes a
+ * `Date.now()`-derived value to animate a Claude-Code-style shimmer while a
+ * keyword is on screen and the prompt is focused; sent message bubbles omit it
+ * to keep the static gradient.
+ */
+export function highlightMagicKeywords(text: string, resetTo?: string, phase?: number): string {
+	return highlightWorkflow(
+		highlightOrchestrate(highlightUltrathink(text, resetTo, phase), resetTo, phase),
+		resetTo,
+		phase,
+	);
+}
+
+/**
+ * Cheap test for "does this text contain any magic keyword as standalone prose?".
+ * Short-circuits on a substring probe before paying for the markdown-aware
+ * prose check, so the common "no keyword in buffer" path is just three
+ * `String#indexOf`s. Used by the live editor to gate the shimmer timer.
+ */
+export function hasMagicKeyword(text: string): boolean {
+	if (!text.includes("ultrathink") && !text.includes("orchestrate") && !text.includes("workflowz")) {
+		return false;
+	}
+	return containsUltrathink(text) || containsOrchestrate(text) || containsWorkflow(text);
+}

package/src/modes/markdown-prose.ts

@@ -0,0 +1,247 @@
+/**
+ * Markdown structure awareness for the magic-keyword affordances
+ * ("ultrathink"/"orchestrate"/"workflowz").
+ *
+ * Keyword detection and editor/transcript highlighting must fire only on prose
+ * the user is actually addressing to the model — never on a word that happens to
+ * live inside a fenced code block, an inline code span, or an HTML/XML section.
+ * {@link maskNonProse} returns a length-preserving copy of the text where every
+ * such region is blanked to spaces, so a word-bounded match run against the mask
+ * never lands inside code/markup while its indices still address the original
+ * text for painting.
+ */
+
+// Tag/element name: HTML5/XML start char + name chars. Sticky so we can probe at
+// a precise offset without slicing.
+const TAG_NAME = /[A-Za-z][A-Za-z0-9-]*/y;
+
+// A line that opens or closes a fenced code block: up to 3 leading spaces then a
+// run of >=3 backticks or tildes.
+const FENCE = /^( {0,3})([`~]{3,})/;
+
+/** Index just past the run of backticks beginning at `i`. */
+function backtickRunEnd(text: string, i: number, n: number): number {
+	let j = i;
+	while (j < n && text[j] === "`") j++;
+	return j;
+}
+
+/**
+ * Find the closing backtick run that matches an opening run of `runLen`
+ * backticks, scanning from `from`. Returns the index just past the closing run,
+ * or -1 when no run of the exact length exists (an unmatched run is literal text,
+ * not a code span). Already-masked positions (fenced code) are skipped.
+ */
+function findBacktickClose(text: string, from: number, n: number, runLen: number, masked: Uint8Array): number {
+	let k = from;
+	while (k < n) {
+		if (masked[k]) {
+			k++;
+			continue;
+		}
+		if (text[k] === "`") {
+			const e = backtickRunEnd(text, k, n);
+			if (e - k === runLen) return e;
+			k = e;
+			continue;
+		}
+		k++;
+	}
+	return -1;
+}
+
+/**
+ * Index of the `>` that closes a tag whose attributes begin at `j`, honoring
+ * quoted attribute values. Returns -1 when the tag is malformed (a new `<`
+ * appears first, or there is no `>`), so callers can treat the `<` as literal.
+ */
+function findTagEnd(text: string, j: number, n: number): number {
+	let quote = "";
+	for (let k = j; k < n; k++) {
+		const ch = text[k];
+		if (quote) {
+			if (ch === quote) quote = "";
+			continue;
+		}
+		if (ch === '"' || ch === "'") {
+			quote = ch;
+			continue;
+		}
+		if (ch === ">") return k;
+		if (ch === "<") return -1;
+	}
+	return -1;
+}
+
+/**
+ * Locate the `</name>` that balances an opening `<name>` at `start`, counting
+ * nested same-name tags. Returns the index just past the matching close tag's
+ * `>`, or -1 when the section is never closed (so callers mask only the opening
+ * tag rather than swallowing the rest of the document).
+ */
+function findMatchingClose(text: string, start: number, n: number, name: string, masked: Uint8Array): number {
+	const lname = name.toLowerCase();
+	let depth = 1;
+	let k = start;
+	while (k < n) {
+		if (masked[k] || text[k] !== "<") {
+			k++;
+			continue;
+		}
+		let m = k + 1;
+		let isClose = false;
+		if (text[m] === "/") {
+			isClose = true;
+			m++;
+		}
+		TAG_NAME.lastIndex = m;
+		const nm = TAG_NAME.exec(text);
+		if (!nm) {
+			k++;
+			continue;
+		}
+		const gt = findTagEnd(text, TAG_NAME.lastIndex, n);
+		if (gt < 0) {
+			k++;
+			continue;
+		}
+		if (nm[0].toLowerCase() === lname) {
+			if (isClose) {
+				depth--;
+				if (depth === 0) return gt + 1;
+			} else if (text[gt - 1] !== "/") {
+				depth++;
+			}
+		}
+		k = gt + 1;
+	}
+	return -1;
+}
+
+/**
+ * Mask the HTML/XML construct beginning at `<` (index `i`): an HTML comment, a
+ * self-closing/closing tag (the tag alone), or an opening tag together with the
+ * content through its matching close tag. Returns the index just past the masked
+ * region, or `i` when the `<` does not begin a tag (e.g. a stray less-than).
+ */
+function maskTagAt(text: string, i: number, n: number, masked: Uint8Array): number {
+	if (text.startsWith("<!--", i)) {
+		const end = text.indexOf("-->", i + 4);
+		const stop = end < 0 ? n : end + 3;
+		for (let p = i; p < stop; p++) masked[p] = 1;
+		return stop;
+	}
+	let j = i + 1;
+	let closing = false;
+	if (text[j] === "/") {
+		closing = true;
+		j++;
+	}
+	TAG_NAME.lastIndex = j;
+	const nm = TAG_NAME.exec(text);
+	if (!nm) return i;
+	const gt = findTagEnd(text, TAG_NAME.lastIndex, n);
+	if (gt < 0) return i;
+	const tagEnd = gt + 1;
+	const selfClosing = text[gt - 1] === "/";
+	for (let p = i; p < tagEnd; p++) masked[p] = 1;
+	if (closing || selfClosing) return tagEnd;
+	const close = findMatchingClose(text, tagEnd, n, nm[0], masked);
+	if (close < 0) return tagEnd;
+	for (let p = tagEnd; p < close; p++) masked[p] = 1;
+	return close;
+}
+
+/**
+ * Return a copy of `text` with identical length (indices map 1:1) where every
+ * character inside a non-prose region is replaced by a space. Non-prose regions
+ * are markdown fenced code blocks, inline code spans, and HTML/XML tags together
+ * with the content they enclose. Newlines are preserved. Text with no construct
+ * that could open such a region is returned unchanged.
+ */
+export function maskNonProse(text: string): string {
+	if (!text.includes("`") && !text.includes("<") && !text.includes("~~~")) {
+		return text;
+	}
+	const n = text.length;
+	const masked = new Uint8Array(n);
+
+	// Phase 1: fenced code blocks, line by line.
+	let fenceChar = "";
+	let fenceLen = 0;
+	let lineStart = 0;
+	while (lineStart <= n) {
+		let nl = text.indexOf("\n", lineStart);
+		if (nl < 0) nl = n;
+		const line = text.slice(lineStart, nl);
+		const open = FENCE.exec(line);
+		if (fenceChar) {
+			for (let p = lineStart; p < nl; p++) masked[p] = 1;
+			// A closing fence is the same char, at least as long, with nothing else on the line.
+			if (
+				open &&
+				open[2]![0] === fenceChar &&
+				open[2]!.length >= fenceLen &&
+				line.slice(open[1]!.length + open[2]!.length).trim() === ""
+			) {
+				fenceChar = "";
+				fenceLen = 0;
+			}
+		} else if (open) {
+			const marker = open[2]!;
+			const ch = marker[0]!;
+			// A backtick fence's info string may not contain a backtick.
+			if (!(ch === "`" && line.slice(open[1]!.length + marker.length).includes("`"))) {
+				fenceChar = ch;
+				fenceLen = marker.length;
+				for (let p = lineStart; p < nl; p++) masked[p] = 1;
+			}
+		}
+		if (nl === n) break;
+		lineStart = nl + 1;
+	}
+
+	// Phase 2: inline code spans and HTML/XML, over not-yet-masked regions.
+	let i = 0;
+	while (i < n) {
+		if (masked[i]) {
+			i++;
+			continue;
+		}
+		const c = text[i];
+		if (c === "`") {
+			const runEnd = backtickRunEnd(text, i, n);
+			const close = findBacktickClose(text, runEnd, n, runEnd - i, masked);
+			if (close >= 0) {
+				for (let p = i; p < close; p++) masked[p] = 1;
+				i = close;
+			} else {
+				i = runEnd;
+			}
+			continue;
+		}
+		if (c === "<") {
+			const end = maskTagAt(text, i, n, masked);
+			i = end > i ? end : i + 1;
+			continue;
+		}
+		i++;
+	}
+
+	const arr = text.split("");
+	for (let p = 0; p < n; p++) {
+		if (masked[p] && arr[p] !== "\n") arr[p] = " ";
+	}
+	return arr.join("");
+}
+
+/**
+ * Whether `text` contains a standalone keyword match (per the non-global,
+ * word-bounded `word` regex) that lives in prose rather than inside a code
+ * block, inline code span, or HTML/XML section. `word` MUST be non-global so
+ * `.test` stays stateless.
+ */
+export function keywordInProse(text: string, word: RegExp): boolean {
+	if (!word.test(text)) return false;
+	return word.test(maskNonProse(text));
+}

package/src/modes/oauth-manual-input.ts

@@ -0,0 +1,69 @@
+type PendingInput = {
+	providerId: string;
+	resolve: (value: string) => void;
+	reject: (error: Error) => void;
+};
+type ClaimedInput = {
+	promise: Promise<string>;
+	clear: (reason?: string) => void;
+};
+
+export class OAuthManualInputManager {
+	#pending?: PendingInput;
+
+	waitForInput(providerId: string): Promise<string> {
+		if (this.#pending) {
+			this.clear("Manual OAuth input superseded by a new login");
+		}
+
+		const pending = this.#createPending(providerId);
+		this.#pending = pending;
+		return pending.promise;
+	}
+
+	tryWaitForInput(providerId: string): Promise<string> | undefined {
+		if (this.#pending) return undefined;
+		return this.waitForInput(providerId);
+	}
+
+	tryClaimInput(providerId: string): ClaimedInput | undefined {
+		if (this.#pending) return undefined;
+		const pending = this.#createPending(providerId);
+		this.#pending = pending;
+		return {
+			promise: pending.promise,
+			clear: (reason?: string) => {
+				if (this.#pending !== pending) return;
+				this.clear(reason);
+			},
+		};
+	}
+
+	submit(input: string): boolean {
+		if (!this.#pending) return false;
+		const { resolve } = this.#pending;
+		this.#pending = undefined;
+		resolve(input);
+		return true;
+	}
+
+	clear(reason = "Manual OAuth input cleared"): void {
+		if (!this.#pending) return;
+		const { reject } = this.#pending;
+		this.#pending = undefined;
+		reject(new Error(reason));
+	}
+
+	hasPending(): boolean {
+		return Boolean(this.#pending);
+	}
+
+	get pendingProviderId(): string | undefined {
+		return this.#pending?.providerId;
+	}
+
+	#createPending(providerId: string): PendingInput & { promise: Promise<string> } {
+		const { promise, resolve, reject } = Promise.withResolvers<string>();
+		return { providerId, resolve, reject, promise };
+	}
+}