@iowarp/clio-coder 0.3.9 → 0.4.0

package/src/cli/configure.ts

@@ -19,6 +19,8 @@ import {
 	listKnownModelsForRuntime,
 	listProviderSupportEntries,
 	type ProviderSupportEntry,
+	readTargetModelSnapshot,
+	recordTargetModelSnapshot,
 	resolveRuntimeAuthTarget,
 	supportGroupLabel,
 } from "../domains/providers/index.js";
@@ -103,6 +105,7 @@ const DEFAULT_PORTS: Record<string, number> = {
 	lemonade: 8000,
 	"anthropic-compat": 8000,
 	"openai-compat": 8000,
+	litellm: 4000,
 };
 
 interface ParsedArgs {
@@ -317,7 +320,9 @@ function printRuntimeList(includeHidden: boolean): void {
 				: runtime?.auth === "api-key"
 					? status?.available
 						? "credential"
-						: "needs-key"
+						: targetRequiresAuth({ id: entry.runtimeId, runtime: entry.runtimeId }, runtime)
+							? "needs-key"
+							: "key-optional"
 					: (runtime?.auth ?? "none");
 		rows.push({
 			group: supportGroupLabel(entry.group),
@@ -387,8 +392,8 @@ function catalogContextWindowFor(runtime: RuntimeDescriptor, modelId: string): n
 /**
  * Check the resolved model against the catalog where there is one and against
  * the target's own list where there is not. A runtime with no catalog used to
- * pass any string here while the same command wrote the live list that ruled
- * it out into `wireModels`, so the target saved as `ok` and failed on its first
+ * pass any string here while the same command had a live list that ruled it
+ * out, so the target saved as `ok` and failed on its first
  * turn. Without a catalog or a live list there is nothing to check against, and
  * the note says so rather than implying the id was verified.
  */
@@ -617,7 +622,6 @@ function buildDescriptor(
 	parts: {
 		url?: string;
 		model?: string;
-		wireModels?: string[];
 		apiKeyEnv?: string;
 		apiKeyRef?: string;
 		oauthProfile?: string;
@@ -631,19 +635,12 @@ function buildDescriptor(
 ): TargetDescriptor {
 	const descriptor: TargetDescriptor = { id, runtime: runtime.id };
 	if (parts.url) descriptor.url = parts.url;
-	const wireModels =
-		parts.wireModels?.filter((value, index, all) => value.trim().length > 0 && all.indexOf(value) === index) ?? [];
 	if (parts.model) descriptor.defaultModel = parts.model;
-	else {
-		const firstWireModel = wireModels[0];
-		if (firstWireModel) descriptor.defaultModel = firstWireModel;
-	}
 	const auth: NonNullable<TargetDescriptor["auth"]> = {};
 	if (parts.apiKeyEnv) auth.apiKeyEnvVar = parts.apiKeyEnv;
 	if (parts.apiKeyRef) auth.apiKeyRef = parts.apiKeyRef;
 	if (parts.oauthProfile) auth.oauthProfile = parts.oauthProfile;
 	if (Object.keys(auth).length > 0) descriptor.auth = auth;
-	if (wireModels.length > 0) descriptor.wireModels = wireModels;
 	if (parts.gateway) descriptor.gateway = true;
 	if (parts.lifecycle) descriptor.lifecycle = parts.lifecycle;
 	const caps: NonNullable<TargetDescriptor["capabilities"]> = {};
@@ -714,7 +711,7 @@ async function loginOAuthRuntime(rl: ReturnType<typeof createInterface>, runtime
  */
 interface WireModelInventory {
 	models: string[];
-	source: "catalog" | "probe" | "existing" | "none";
+	source: "catalog" | "probe" | "cache" | "legacy" | "none";
 	/** Per-model load state when the probe reported it. */
 	modelStates?: Readonly<Record<string, ProbeModelStatus>> | undefined;
 }
@@ -761,13 +758,21 @@ async function resolveSupportedWireModels(
 		// lists models only through probeModels still gets its ids checked.
 		const probe = await runtimeProbe(runtime, target, authToken);
 		if (probe?.ok && probe.models && probe.models.length > 0) {
+			recordTargetModelSnapshot(target, probe.models);
 			return { models: [...probe.models], source: "probe", modelStates: probe.modelStates };
 		}
 		const discovered = await runtimeProbeModels(runtime, target, authToken);
-		if (discovered.length > 0) return { models: discovered, source: "probe" };
+		if (discovered.length > 0) {
+			recordTargetModelSnapshot(target, discovered);
+			return { models: discovered, source: "probe" };
+		}
+	}
+	const cached = readTargetModelSnapshot(target);
+	if (cached && cached.models.length > 0) return { models: [...cached.models], source: "cache" };
+	if (existing?.wireModels && existing.wireModels.length > 0) {
+		recordTargetModelSnapshot(target, existing.wireModels);
+		return { models: [...existing.wireModels], source: "legacy" };
 	}
-	if (existing?.wireModels && existing.wireModels.length > 0)
-		return { models: [...existing.wireModels], source: "existing" };
 	return { models: [], source: "none" };
 }
 
@@ -905,7 +910,6 @@ async function runNonInteractive(runtime: RuntimeDescriptor, args: ParsedArgs):
 	const descriptor = buildDescriptor(runtime, args.id, {
 		...(url !== undefined ? { url } : {}),
 		...(model ? { model } : {}),
-		...(wireModels.length > 0 ? { wireModels } : {}),
 		...(apiKeyEnv !== undefined ? { apiKeyEnv } : {}),
 		...(apiKeyRef !== undefined ? { apiKeyRef } : {}),
 		...(oauthProfile !== undefined ? { oauthProfile } : {}),
@@ -966,6 +970,7 @@ async function runNonInteractive(runtime: RuntimeDescriptor, args: ParsedArgs):
 	applyConfiguration(settings);
 	updateSettings(applyConfiguration);
 	const probe = await runtimeProbe(runtime, descriptor);
+	if (probe?.ok && probe.models) recordTargetModelSnapshot(descriptor, probe.models);
 	printSummary(settings, descriptor, probe);
 	if (
 		runtime.auth === "oauth" &&
@@ -1272,10 +1277,7 @@ async function runInteractive(
 	}
 
 	let model: string | undefined = defaults.model;
-	let inventory: WireModelInventory =
-		existing?.wireModels && existing.wireModels.length > 0
-			? { models: [...existing.wireModels], source: "existing" }
-			: { models: [], source: "none" };
+	let inventory: WireModelInventory = { models: [], source: "none" };
 	const tentative = buildDescriptor(runtime, targetId, {
 		...(url !== undefined ? { url } : {}),
 		...(apiKeyEnv !== undefined ? { apiKeyEnv } : {}),
@@ -1367,7 +1369,6 @@ async function runInteractive(
 		...(apiKeyEnv !== undefined ? { apiKeyEnv } : {}),
 		...(apiKeyRef !== undefined ? { apiKeyRef } : {}),
 		...(oauthProfile !== undefined ? { oauthProfile } : {}),
-		...(wireModels.length > 0 ? { wireModels } : {}),
 		gateway: gatewayAnswer,
 		...(defaults.lifecycle !== undefined
 			? { lifecycle: defaults.lifecycle }
@@ -1395,6 +1396,7 @@ async function runInteractive(
 	}
 
 	const probe = await runtimeProbe(runtime, descriptor);
+	if (probe?.ok && probe.models) recordTargetModelSnapshot(descriptor, probe.models);
 	if (probe) {
 		process.stdout.write("\n");
 		for (const line of probeLines(descriptor, probe)) process.stdout.write(`${line}\n`);

package/src/cli/doctor-panes.ts

@@ -0,0 +1,124 @@
+import { accessSync, constants, mkdirSync } from "node:fs";
+import { readSettings } from "../core/config.js";
+import { runEventJournalRoot } from "../domains/dispatch/run-event-journal.js";
+import type { DoctorFinding } from "../domains/lifecycle/doctor.js";
+import { detectMux, MUX_METHOD_MIN_PROTOCOL, resolveSocketCandidates } from "../domains/mux/index.js";
+import { describeResolution, findPinnedTool, toolStatus } from "../domains/toolchain/index.js";
+
+/**
+ * The panes section of `clio-coder doctor`.
+ *
+ * Five rows, in the order an operator debugs them: what mode the pane layer
+ * resolved to, whether the socket answered, whether the server is new enough
+ * for the methods phase 3 uses, where the pane host binary resolves, and
+ * whether the journal directory the viewer reads is writable.
+ *
+ * No row is an error. Panes are optional: an operator who never wanted them has
+ * a healthy install without them, and doctor's exit code answers "is this
+ * install healthy". The rows that would be errors elsewhere are warnings that
+ * name the next step instead.
+ */
+
+const PANE_HOST_TOOL_ID = "herdr";
+
+/** Highest protocol any method Clio drives requires, for the version row. */
+const REQUIRED_PROTOCOL = Math.max(...Object.values(MUX_METHOD_MIN_PROTOCOL));
+
+function journalWritabilityFinding(root = runEventJournalRoot()): DoctorFinding {
+	try {
+		// The viewer reads this tree and the journal writes it, so the useful
+		// question is whether it can exist and be written, not whether it does.
+		mkdirSync(root, { recursive: true });
+		accessSync(root, constants.W_OK);
+		return { ok: true, name: "panes journal dir", detail: `${root} is writable` };
+	} catch (error) {
+		return {
+			ok: true,
+			level: "warn",
+			name: "panes journal dir",
+			detail: `${root} is not writable (${error instanceof Error ? error.message : String(error)}); \`clio-coder fleet view\` will have no transcript to follow`,
+		};
+	}
+}
+
+export async function panesFindings(env: NodeJS.ProcessEnv = process.env): Promise<DoctorFinding[]> {
+	let enabled: "auto" | "embedded" | "off" = "off";
+	try {
+		enabled = readSettings().panes.enabled;
+	} catch {
+		// An unreadable settings file is already reported by the settings row;
+		// this section answers on the shipped default (off) rather than throwing.
+	}
+
+	// Inactive by choice is a different answer from unavailable. With the
+	// setting off, detection is skipped the same way the boot skips it, and the
+	// row names the two ways to turn the extension on instead of warning about
+	// a socket nobody asked for.
+	if (enabled === "off") {
+		return [
+			{
+				ok: true,
+				name: "panes mode",
+				detail:
+					"off by choice (panes.enabled=off); start `clio-coder --with-panes` for one session, or set panes.enabled=auto",
+			},
+			journalWritabilityFinding(),
+		];
+	}
+
+	// Detection is the same ladder the interactive boot runs, so this row is the
+	// answer that boot would get. It opens a socket and nothing else: no file is
+	// created and no pane is touched.
+	const { detection, client } = await detectMux({ enabled, env });
+	await client?.close().catch(() => undefined);
+
+	const candidates = detection.candidates.length > 0 ? detection.candidates : resolveSocketCandidates(env);
+	const findings: DoctorFinding[] = [
+		{
+			ok: true,
+			level: detection.mode === "none" ? "warn" : "ok",
+			name: "panes mode",
+			detail: `${detection.mode} (panes.enabled=${enabled}); ${detection.reason}`,
+		},
+		{
+			ok: true,
+			level: detection.socketPath === null ? "warn" : "ok",
+			name: "panes socket",
+			detail:
+				detection.socketPath === null
+					? `no socket answered; tried ${candidates.length > 0 ? candidates.join(", ") : "no candidates"}`
+					: `${detection.socketPath} answered a ping`,
+		},
+	];
+
+	const server = detection.server;
+	findings.push({
+		ok: true,
+		level: server === null || server.protocol < REQUIRED_PROTOCOL ? "warn" : "ok",
+		name: "panes protocol",
+		detail:
+			server === null
+				? `unknown; Clio's optional methods need protocol ${REQUIRED_PROTOCOL} or newer`
+				: `server ${server.version}, protocol ${server.protocol}; Clio's optional methods need ${REQUIRED_PROTOCOL} (${server.protocol >= REQUIRED_PROTOCOL ? "satisfied" : "toasts and agent focus fall back"})`,
+	});
+
+	const entry = findPinnedTool(PANE_HOST_TOOL_ID);
+	findings.push(
+		entry === null
+			? {
+					ok: true,
+					level: "warn",
+					name: "panes binary",
+					detail: `${PANE_HOST_TOOL_ID} is not in the pinned tool registry`,
+				}
+			: {
+					ok: true,
+					level: toolStatus(entry).resolution.source === "none" ? "warn" : "ok",
+					name: "panes binary",
+					detail: describeResolution(toolStatus(entry)),
+				},
+	);
+
+	findings.push(journalWritabilityFinding());
+	return findings;
+}

package/src/cli/doctor-toolchain.ts

@@ -0,0 +1,57 @@
+import type { DoctorFinding } from "../domains/lifecycle/doctor.js";
+import {
+	describeYaziProfile,
+	inspectCurrentYaziProfile,
+	userYaziConfigDir,
+	yaziProfileDir,
+} from "../domains/mux/index.js";
+import { describeResolution, toolStatuses } from "../domains/toolchain/index.js";
+
+function yaziProfileFinding(): DoctorFinding {
+	try {
+		const profile = inspectCurrentYaziProfile();
+		return {
+			ok: true,
+			name: "yazi managed profile",
+			detail: describeYaziProfile(profile),
+			level: profile.state === "current" ? "ok" : "warn",
+		};
+	} catch (error) {
+		return {
+			ok: true,
+			name: "yazi managed profile",
+			level: "warn",
+			detail: `${yaziProfileDir()} could not be inspected (${error instanceof Error ? error.message : String(error)}); user config ${userYaziConfigDir()} is separate and untouched`,
+		};
+	}
+}
+
+/**
+ * One row per pinned external tool: where it resolves, and how the version
+ * found compares to the pin.
+ *
+ * Every one of these tools is optional, so no row is ever an error. A missing
+ * tool is a WARN with the command that installs it, because doctor's exit code
+ * answers "is this Clio install healthy", and an operator who never wanted
+ * panes has a healthy install without them.
+ *
+ * A PATH copy Clio rejected for being below the registry floor is never
+ * reported as an absent one. The row says which binary was found, what version
+ * it reported, and which floor it missed, and adds the install command only
+ * when there is no vendored copy already answering for the tool. Doctor is the
+ * surface an operator reaches for when a tool they installed themselves is not
+ * being used, and a row that only said "not found" would send them looking for
+ * a binary that is right there on their PATH.
+ */
+export function toolchainFindings(): DoctorFinding[] {
+	const tools = toolStatuses().map((status) => ({
+		ok: true,
+		name: `external tool ${status.id}`,
+		// The rejection and the remedy both live inside the shared resolution
+		// sentence, so this row and `clio-coder tools status` cannot describe the
+		// same machine differently.
+		detail: describeResolution(status),
+		level: status.resolution.source === "none" ? ("warn" as const) : ("ok" as const),
+	}));
+	return [...tools, yaziProfileFinding()];
+}

package/src/cli/doctor.ts

@@ -7,7 +7,9 @@ import {
 	runDoctorModelChecks,
 	runDoctorRuntimeChecks,
 } from "../domains/lifecycle/doctor.js";
+import { panesFindings } from "./doctor-panes.js";
 import { stateStorageFinding } from "./doctor-state-size.js";
+import { toolchainFindings } from "./doctor-toolchain.js";
 import { printError } from "./shared.js";
 
 const HELP = `clio-coder doctor [--fix] [--json]
@@ -49,7 +51,24 @@ export async function runDoctorCommand(args: ReadonlyArray<string> = []): Promis
 	// Fleet preflight probes each configured node over SSH and persists the
 	// per-node eligibility verdicts dispatch placement enforces.
 	const fleetChecks = untouched ? [] : await runDoctorFleetChecks();
-	const all = [...findings, ...storageChecks, ...runtimeChecks, ...modelChecks, ...interopChecks, ...fleetChecks];
+	// Resolution reads PATH and the vendor root and creates nothing, but on an
+	// untouched home there is no vendor root to look at and the answer would be
+	// "none" for every row regardless, so the sweep stays with the others.
+	const toolChecks = untouched ? [] : toolchainFindings();
+	// The pane sweep pings a socket and reads PATH; it creates nothing except the
+	// journal directory it is asked about, which is inside the state root doctor
+	// has already agreed not to build on an untouched home.
+	const paneChecks = untouched ? [] : await panesFindings();
+	const all = [
+		...findings,
+		...storageChecks,
+		...runtimeChecks,
+		...modelChecks,
+		...interopChecks,
+		...fleetChecks,
+		...toolChecks,
+		...paneChecks,
+	];
 	const ok = all.every((f) => f.ok);
 	if (json) {
 		process.stdout.write(`${JSON.stringify({ ok, fix, findings: all }, null, 2)}\n`);