@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/cli/config-inspect.ts

@@ -16,7 +16,7 @@ import { basename, join } from "node:path";
 import type { ClioSettings } from "../core/config.js";
 import { resolvePackageRoot } from "../core/package-root.js";
 import { readLayeredSettings, type SettingsOrigin, settingsSourceFor } from "../core/settings-layers.js";
-import { clioDataDir } from "../core/xdg.js";
+import { clioDataDir, clioStateDir } from "../core/xdg.js";
 import {
 	loadOperatorProfile,
 	loadProjectClioMd,
@@ -24,12 +24,18 @@ import {
 	renderOperatorProfile,
 	renderPromptContext,
 } from "../domains/context/index.js";
-import { listInstalledExtensions } from "../domains/extensions/index.js";
+import { extensionSnapshotFor, listInstalledExtensions } from "../domains/extensions/index.js";
 import { loadMemoryRecordsSync, memoryStorePath } from "../domains/memory/index.js";
-import { loadUserHooks, readHookSources } from "../domains/middleware/index.js";
+import {
+	HOOK_RECEIPT_LOG_CAPACITY,
+	loadUserHooks,
+	readHookSources,
+	readPersistedHookReceipts,
+} from "../domains/middleware/index.js";
 import { classifyProjectPreload } from "../domains/prompts/preload.js";
 import { defaultScopedResourceRoots } from "../domains/resources/common-loader.js";
 import { ceilChars } from "../domains/session/context-accounting.js";
+import { capturedHookSourcesFor } from "../entry/extension-hook-sources.js";
 
 export type CustomizationCategory =
 	| "settings"
@@ -45,7 +51,8 @@ export type CustomizationCategory =
 	| "safety"
 	| "memory";
 
-export type ReloadClass = "hot" | "next-turn" | "restart" | "n/a";
+/** `reload` means an explicit `/resources extensions reload` (or a restart) publishes the change. */
+export type ReloadClass = "hot" | "next-turn" | "reload" | "restart" | "n/a";
 
 export interface CustomizationEntry {
 	category: CustomizationCategory;
@@ -203,10 +210,13 @@ function inspectOperatorProfile(cwd: string, graph: CustomizationGraph): void {
 
 function inspectHooks(cwd: string, graph: CustomizationGraph): void {
 	try {
-		const extensions = listInstalledExtensions(cwd)
-			.filter((ext) => ext.enabled && ext.effective)
-			.map((ext) => ({ id: ext.id, rootPath: ext.rootPath }));
-		const { batches, fileIssues } = readHookSources({ cwd, extensions });
+		// Extension declarations come from the same captured bytes a booted
+		// session admits; an inspecting process without a bound store builds an
+		// ephemeral generation-0 projection.
+		const { batches, fileIssues } = readHookSources({
+			cwd,
+			capturedSources: capturedHookSourcesFor(extensionSnapshotFor(cwd)),
+		});
 		for (const issue of fileIssues) graph.issues.push(`hook ${issue.source.origin}: ${issue.message}`);
 		const loaded = loadUserHooks(batches, { workspaceRoot: cwd });
 		for (const issue of loaded.issues) {
@@ -221,7 +231,7 @@ function inspectHooks(cwd: string, graph: CustomizationGraph): void {
 				hash: hook.hash,
 				trust: hook.source.origin === "extension" ? "untrusted" : "trusted",
 				precedence: "winner",
-				reloadClass: "restart",
+				reloadClass: "reload",
 				detail: { on: hook.on, kind: hook.spec.kind, enabled: hook.enabled, ...(hook.tools ? { tools: hook.tools } : {}) },
 			});
 		}
@@ -234,7 +244,7 @@ function inspectHooks(cwd: string, graph: CustomizationGraph): void {
 				hash: loser.hash,
 				trust: loser.source.origin === "extension" ? "untrusted" : "trusted",
 				precedence: "loser",
-				reloadClass: "restart",
+				reloadClass: "reload",
 				detail: { on: loser.on, kind: loser.spec.kind },
 			});
 		}
@@ -243,6 +253,42 @@ function inspectHooks(cwd: string, graph: CustomizationGraph): void {
 	}
 }
 
+/**
+ * Rolls up the durable hook-execution receipt log (`<stateDir>/hook-receipts.json`,
+ * written by `createHookReceiptLog` in `src/domains/middleware/hook-receipts.ts`)
+ * into one entry, since this process never held the live in-memory ring a
+ * running session's own invocation writes through. One entry rather than one
+ * per receipt: this graph explains configuration provenance, and a couple
+ * hundred execution rows would swamp that rather than answer it.
+ */
+function inspectHookReceipts(graph: CustomizationGraph): void {
+	const path = join(clioStateDir(), "hook-receipts.json");
+	try {
+		const receipts = existsSync(path) ? readPersistedHookReceipts(path) : [];
+		const outcomes: Record<string, number> = {};
+		for (const receipt of receipts) outcomes[receipt.outcome] = (outcomes[receipt.outcome] ?? 0) + 1;
+		const last = receipts.at(-1);
+		graph.entries.push({
+			category: "hook",
+			id: "hook-receipts",
+			scope: "user",
+			sourcePath: path,
+			reloadClass: "n/a",
+			trust: "n/a",
+			precedence: "single",
+			detail: {
+				present: existsSync(path),
+				count: receipts.length,
+				capacity: HOOK_RECEIPT_LOG_CAPACITY,
+				outcomes,
+				...(last === undefined ? {} : { mostRecent: { at: last.at, hookId: last.hookId, outcome: last.outcome } }),
+			},
+		});
+	} catch (err) {
+		graph.issues.push(`hook-receipts: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
 function inspectExtensions(cwd: string, graph: CustomizationGraph): void {
 	try {
 		for (const ext of listInstalledExtensions(cwd, { all: true })) {
@@ -254,8 +300,14 @@ function inspectExtensions(cwd: string, graph: CustomizationGraph): void {
 				hash: shortHash(`${ext.id}@${ext.version}`),
 				trust: "untrusted",
 				precedence: ext.effective ? "winner" : "loser",
-				reloadClass: "restart",
-				detail: { version: ext.version, enabled: ext.enabled, effective: ext.effective },
+				reloadClass: "reload",
+				detail: {
+					version: ext.version,
+					enabled: ext.enabled,
+					valid: ext.valid,
+					effective: ext.effective,
+					loadable: ext.loadable,
+				},
 			});
 		}
 	} catch (err) {
@@ -356,6 +408,7 @@ export function buildCustomizationGraph(cwd: string): CustomizationGraph {
 	inspectRules(cwd, graph);
 	inspectOperatorProfile(cwd, graph);
 	inspectHooks(cwd, graph);
+	inspectHookReceipts(graph);
 	inspectExtensions(cwd, graph);
 	inspectResourceRoots(cwd, graph);
 	inspectSafetyAndMemory(cwd, graph);

package/src/cli/configure-interop.ts

@@ -1,5 +1,7 @@
 import { stdout as output } from "node:process";
 import type { createInterface } from "node:readline/promises";
+import chalk from "chalk";
+
 import { readSettings } from "../core/config.js";
 import {
 	acceptInteropAgents,
@@ -12,6 +14,9 @@ import {
 	renderProposalEntry,
 } from "../domains/interop/index.js";
 import { askYesNo } from "./ask.js";
+import { railPrefix } from "./configure-target.js";
+import { createLifecyclePresenter, type LifecyclePresenter } from "./lifecycle-presenter.js";
+import { canSelect, promptMultiSelect } from "./select.js";
 import { printOk } from "./shared.js";
 
 function describe(proposal: InteropProposal): string {
@@ -30,38 +35,125 @@ function describe(proposal: InteropProposal): string {
 	return `${lines.join("\n")}\n`;
 }
 
+/** What one row of the picker says about an agent, beyond its name. */
+function proposalHint(proposal: InteropProposal): string {
+	const command = [proposal.entry.command, ...(proposal.entry.args ?? [])].join(" ");
+	return proposal.needsNetworkInstall ? `${command} (npx fetches the adapter on first use)` : command;
+}
+
+export interface InteropReviewStreams {
+	in: NodeJS.ReadableStream;
+	out: NodeJS.WritableStream;
+}
+
+export interface InteropReviewIo {
+	/** Readline interface for the numbered fallback. Null means nothing can answer. */
+	rl: ReturnType<typeof createInterface> | null;
+	streams?: InteropReviewStreams;
+	/** Rail to draw on when the caller already owns one. */
+	presenter?: LifecyclePresenter;
+	rail?: string;
+	/** Skip the "nothing to connect" line, for a caller whose transcript says enough. */
+	quiet?: boolean;
+}
+
+export interface InteropReviewOutcome {
+	code: number;
+	/** Agent ids that were wired, in the order they were written. */
+	wired: string[];
+	/** The user left the review without answering it. */
+	back: boolean;
+}
+
 /**
  * Review detected agents and, with an explicit answer per agent, wire them as
  * delegation peers. Without a TTY this prints the proposals and writes nothing:
  * no code path adds a peer the operator did not agree to.
+ *
+ * On a terminal this is one multi-select rather than a run of `[y/N]`
+ * questions. The questions were identical apart from a name, they hid how many
+ * there were, and once the second one was on screen the first could not be
+ * changed. The per-agent paragraph they each carried says the same two facts
+ * every time, so it is stated once above the list and the row carries what is
+ * actually different: the command Clio would run.
  */
-export async function runInteropReview(rl: ReturnType<typeof createInterface> | null): Promise<number> {
+export async function reviewInteropAgents(io: InteropReviewIo): Promise<InteropReviewOutcome> {
 	const report = await detectInteropAgents({ cwd: process.cwd(), probeVersion: true });
 	const proposals = interopProposals(report, readSettings());
 	if (proposals.length === 0) {
-		output.write("No new coding agents to connect.\n");
-		return 0;
+		if (!io.quiet) output.write("No new coding agents to connect.\n");
+		return { code: 0, wired: [], back: false };
 	}
-	if (rl === null) {
+	const streams = io.streams;
+	// The picker needs a terminal, not a readline interface; the caller that owns
+	// the rail deliberately keeps no readline open, because one left attached
+	// echoes the keys the picker is reading.
+	const interactive =
+		streams !== undefined && canSelect(streams.in as NodeJS.ReadStream, streams.out as NodeJS.WriteStream);
+	if (!interactive && io.rl === null) {
 		for (const proposal of proposals) output.write(describe(proposal));
 		output.write("\nRun `clio-coder configure --interop` on a terminal to connect any of these.\n");
-		return 0;
+		return { code: 0, wired: [], back: false };
 	}
+
 	const accepted: InteropAgentId[] = [];
 	const declined: InteropAgentId[] = [];
-	for (const proposal of proposals) {
-		output.write(describe(proposal));
-		const yes = await askYesNo(rl, `Add ${proposal.label} as delegation agent \`${proposal.entry.id}\`?`, false);
-		(yes ? accepted : declined).push(proposal.kind);
+
+	if (interactive && streams) {
+		const presenter = io.presenter ?? createLifecyclePresenter({ stream: streams.out });
+		const rail = io.rail ?? railPrefix(presenter.isPlain());
+		presenter.note(
+			`Clio found ${proposals.length === 1 ? "one coding agent" : `${proposals.length} coding agents`} it can delegate to. A peer receives your task text and never the project projection, and its tool calls are gated by Clio safety.`,
+		);
+		const result = await promptMultiSelect<InteropAgentId>({
+			heading: ["", chalk.bold("Delegate to any of these?")],
+			choices: proposals.map((proposal) => ({
+				value: proposal.kind,
+				label: proposal.label,
+				hint: proposalHint(proposal),
+			})),
+			railPrefix: rail,
+			backLabel: "back",
+			confirmLabel: "confirm",
+			clearOnExit: true,
+			input: streams.in as NodeJS.ReadStream,
+			output: streams.out as NodeJS.WriteStream,
+		});
+		if (result.kind === "back") return { code: 0, wired: [], back: true };
+		if (result.kind === "quit") return { code: 0, wired: [], back: false };
+		for (const proposal of proposals) {
+			(result.values.includes(proposal.kind) ? accepted : declined).push(proposal.kind);
+		}
+	} else if (io.rl !== null) {
+		for (const proposal of proposals) {
+			output.write(describe(proposal));
+			const yes = await askYesNo(io.rl, `Add ${proposal.label} as delegation agent \`${proposal.entry.id}\`?`, false);
+			(yes ? accepted : declined).push(proposal.kind);
+		}
 	}
+
+	const wired: string[] = [];
 	if (accepted.length > 0) {
 		const result = acceptInteropAgents(accepted, report);
-		for (const diagnostic of result.diagnostics) output.write(`note: ${diagnostic}\n`);
-		for (const id of result.wired) printOk(`delegation agent ${id} added; use \`/delegate ${id} <task>\``);
+		for (const diagnostic of result.diagnostics) {
+			if (io.presenter) io.presenter.warn(diagnostic);
+			else output.write(`note: ${diagnostic}\n`);
+		}
+		for (const id of result.wired) {
+			wired.push(id);
+			// A caller with a rail lists what it wrote in its own completion rows.
+			if (!io.presenter) printOk(`delegation agent ${id} added; use \`/delegate ${id} <task>\``);
+		}
 	}
 	if (declined.length > 0) {
 		declineInteropAgents(declined, report);
-		output.write(`Declined ${declined.join(", ")}; Clio stays quiet about them until their version or path changes.\n`);
+		const line = `Declined ${declined.join(", ")}; Clio stays quiet about them until their version or path changes.`;
+		if (io.presenter) io.presenter.note(line);
+		else output.write(`${line}\n`);
 	}
-	return 0;
+	return { code: 0, wired, back: false };
+}
+
+export async function runInteropReview(io: InteropReviewIo): Promise<number> {
+	return (await reviewInteropAgents(io)).code;
 }

package/src/cli/configure-oauth.ts

@@ -0,0 +1,57 @@
+/**
+ * The browser sign-in half of `clio-coder configure`.
+ *
+ * This stays on readline rather than the arrow-key prompts: an OAuth flow ends
+ * with a code the user pastes, and there is no list to choose from. It lives in
+ * its own file so the first-run wizard can start a login without importing the
+ * rest of configure.ts.
+ */
+import type { createInterface } from "node:readline/promises";
+
+import { openAuthStorage } from "../domains/providers/auth/index.js";
+import type { RuntimeDescriptor } from "../domains/providers/types/runtime-descriptor.js";
+import { createDelayedManualCodeInput } from "./oauth-manual-input.js";
+import { promptOAuthSelection } from "./oauth-select.js";
+import { credentialWriteFailed, printError, printOk } from "./shared.js";
+
+export async function loginOAuthRuntime(
+	rl: ReturnType<typeof createInterface>,
+	runtime: RuntimeDescriptor,
+): Promise<boolean> {
+	const auth = openAuthStorage();
+	if (runtime.authNotice) process.stdout.write(`note: ${runtime.authNotice}\n`);
+	const manualCodeInput = createDelayedManualCodeInput(
+		rl,
+		"Paste verification code if browser callback does not complete automatically: ",
+	);
+	try {
+		await auth.login(runtime.oauthProviderId ?? runtime.id, {
+			onAuth: ({ url, instructions }) => {
+				process.stdout.write(`\nOpen: ${url}\n`);
+				if (instructions) process.stdout.write(`${instructions}\n`);
+				process.stdout.write("Waiting for the browser callback. A manual code prompt will appear if needed.\n");
+			},
+			onDeviceCode: ({ verificationUri, userCode }) => {
+				process.stdout.write(`\nOpen: ${verificationUri}\n`);
+				process.stdout.write(`Enter code: ${userCode}\n`);
+			},
+			onPrompt: async (prompt) => {
+				const answer = await rl.question(`${prompt.message}${prompt.allowEmpty ? " " : ": "}`);
+				return prompt.allowEmpty ? answer : answer.trim();
+			},
+			onSelect: (prompt) => promptOAuthSelection(rl, prompt),
+			onManualCodeInput: manualCodeInput.onManualCodeInput,
+			onProgress: (message) => {
+				process.stderr.write(`${message}\n`);
+			},
+		});
+		if (credentialWriteFailed(auth, `credential for ${runtime.id} was not stored`)) return false;
+		printOk(`authenticated ${runtime.id}`);
+		return true;
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		return false;
+	} finally {
+		manualCodeInput.cancel();
+	}
+}