@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/cli/targets.ts

@@ -205,8 +205,7 @@ export async function runTargetsCommand(args: ReadonlyArray<string>): Promise<nu
 	if (parsed.json) {
 		const settings = readSettings();
 		const candidateFor = (status: TargetStatus): string | null => {
-			const orchestratorModel =
-				settings.orchestrator?.target === status.target.id ? (settings.orchestrator?.model ?? null) : null;
+			const orchestratorModel = settings.chat?.target === status.target.id ? (settings.chat?.model ?? null) : null;
 			return orchestratorModel ?? status.target.defaultModel ?? null;
 		};
 		const rows = filtered.map((status) => {
@@ -467,11 +466,11 @@ function runProfileRemove(args: ReadonlyArray<string>): number {
 	}
 	ensureClioState();
 	const settings = readSettings();
-	if (!settings.workers.profiles[parsed.name]) {
+	if (!settings.fleet.profiles[parsed.name]) {
 		printError(`no fleet profile named ${parsed.name}`);
 		return 1;
 	}
-	const boundAgents = Object.entries(settings.workers.agentBindings)
+	const boundAgents = Object.entries(settings.fleet.agentProfiles)
 		.filter(([, profileName]) => profileName === parsed.name)
 		.map(([agentId]) => agentId);
 	if (boundAgents.length > 0 && !parsed.force) {
@@ -510,23 +509,23 @@ function runProfileRename(args: ReadonlyArray<string>): number {
 	}
 	ensureClioState();
 	const settings = readSettings();
-	if (!settings.workers.profiles[parsed.oldName]) {
+	if (!settings.fleet.profiles[parsed.oldName]) {
 		printError(`no fleet profile named ${parsed.oldName}`);
 		return 1;
 	}
-	if (settings.workers.profiles[parsed.newName]) {
+	if (settings.fleet.profiles[parsed.newName]) {
 		printError(`fleet profile already exists: ${parsed.newName}`);
 		return 2;
 	}
 	let updatedBindings = 0;
 	updateSettings((fresh) => {
-		const profile = fresh.workers.profiles[parsed.oldName];
+		const profile = fresh.fleet.profiles[parsed.oldName];
 		if (!profile) return;
-		fresh.workers.profiles[parsed.newName] = profile;
-		delete fresh.workers.profiles[parsed.oldName];
-		for (const [agentId, profileName] of Object.entries(fresh.workers.agentBindings)) {
+		fresh.fleet.profiles[parsed.newName] = profile;
+		delete fresh.fleet.profiles[parsed.oldName];
+		for (const [agentId, profileName] of Object.entries(fresh.fleet.agentProfiles)) {
 			if (profileName !== parsed.oldName) continue;
-			fresh.workers.agentBindings[agentId] = parsed.newName;
+			fresh.fleet.agentProfiles[agentId] = parsed.newName;
 			updatedBindings += 1;
 		}
 	});
@@ -551,13 +550,13 @@ function runProfileBind(args: ReadonlyArray<string>): number {
 	}
 	ensureClioState();
 	const settings = readSettings();
-	if (settings.delegation.agents.some((agent) => agent.id === parsed.agentId)) {
+	if (settings.integrations.externalAgents.entries.some((agent) => agent.id === parsed.agentId)) {
 		printError(
 			`cannot bind ACP delegation agent '${parsed.agentId}' to a fleet profile; ACP agents use their own runner and ignore native target routing`,
 		);
 		return 1;
 	}
-	if (!settings.workers.profiles[parsed.profileName]) {
+	if (!settings.fleet.profiles[parsed.profileName]) {
 		process.stderr.write(
 			`${chalk.yellow("warning:")} fleet profile '${parsed.profileName}' is not configured; binding will resolve after the profile exists\n`,
 		);
@@ -581,12 +580,12 @@ function runProfileUnbind(args: ReadonlyArray<string>): number {
 	}
 	ensureClioState();
 	const settings = readSettings();
-	if (!settings.workers.agentBindings[parsed]) {
+	if (!settings.fleet.agentProfiles[parsed]) {
 		printError(`agent ${parsed} is not bound to a fleet profile`);
 		return 1;
 	}
 	updateSettings((fresh) => {
-		delete fresh.workers.agentBindings[parsed];
+		delete fresh.fleet.agentProfiles[parsed];
 	});
 	printOk(`unbound agent ${parsed}`);
 	return 0;
@@ -608,10 +607,10 @@ function runProfileBindings(args: ReadonlyArray<string>): number {
 	}
 	ensureClioState();
 	const settings = readSettings();
-	const rows = Object.entries(settings.workers.agentBindings)
+	const rows = Object.entries(settings.fleet.agentProfiles)
 		.sort(([a], [b]) => a.localeCompare(b))
 		.map(([agentId, profileName]) => {
-			const profile = settings.workers.profiles[profileName];
+			const profile = settings.fleet.profiles[profileName];
 			return {
 				agentId,
 				profile: profileName,
@@ -686,7 +685,7 @@ function runFleet(args: ReadonlyArray<string>, usage = "clio-coder targets fleet
 	ensureClioState();
 	const settings = readSettings();
 	const byId = new Map(settings.targets.map((target) => [target.id, target] as const));
-	const rows = Object.entries(settings.workers.profiles).map(([name, profile]) => {
+	const rows = Object.entries(settings.fleet.profiles).map(([name, profile]) => {
 		const target = profile.target ? byId.get(profile.target) : undefined;
 		return {
 			name,
@@ -782,7 +781,7 @@ function runConvert(args: ReadonlyArray<string>): number {
 		printOk(`target ${id} already uses runtime ${runtimeId}`);
 		return 0;
 	}
-	if (settings.orchestrator.target === id && !isOrchestratorEligibleRuntime(runtime)) {
+	if (settings.chat.target === id && !isOrchestratorEligibleRuntime(runtime)) {
 		printError(`cannot convert orchestrator target '${id}' to non-HTTP/native runtime '${runtime.id}'`);
 		return 1;
 	}
@@ -917,7 +916,7 @@ function tableWidths(rows: ReadonlyArray<TargetTableRow>, width: number): Target
  * cut to its width, marked the same way. Colour is dropped on those rows because
  * the ansi bytes would sit inside the cut; a wrapped row costs more than colour.
  */
-export function formatTargetTable(
+function formatTargetTable(
 	rows: ReadonlyArray<TargetTableRow>,
 	width: number,
 	paintHealth: (cell: string, row: TargetTableRow) => string = (cell) => cell,
@@ -972,7 +971,7 @@ function renderTable(providers: ProvidersContract, entries: ReadonlyArray<Target
 	}
 }
 
-export function targetTableRow(providers: ProvidersContract, status: TargetStatus): TargetTableRow {
+function targetTableRow(providers: ProvidersContract, status: TargetStatus): TargetTableRow {
 	const diagnostic = degradedHealthDiagnostic(status);
 	return {
 		id: status.target.id,
@@ -1034,7 +1033,7 @@ function capabilityBadges(caps: CapabilityFlags): string {
  * no states (cloud targets); "resident: none" when states are known and
  * nothing is loaded, so a cold box is distinguishable from an unknown one.
  */
-export function residentModelsSummary(states: TargetStatus["discoveredModelStates"]): string | null {
+function residentModelsSummary(states: TargetStatus["discoveredModelStates"]): string | null {
 	if (!states) return null;
 	const entries = Object.entries(states);
 	if (entries.length === 0) return null;
@@ -1049,7 +1048,7 @@ export function residentModelsSummary(states: TargetStatus["discoveredModelState
  * capability the target reported. Saying so is the difference between a number
  * a user can plan against and one they cannot.
  */
-export function formatContextWindow(
+function formatContextWindow(
 	status: Pick<TargetStatus, "capabilities" | "contextWindowProvenance"> &
 		Partial<Pick<TargetStatus, "target" | "discoveredModelStates">>,
 ): string {
@@ -1065,7 +1064,7 @@ export function formatContextWindow(
 		: `ctx ${window}`;
 }
 
-export function formatNotes(status: TargetStatus): string {
+function formatNotes(status: TargetStatus): string {
 	const parts: string[] = [];
 	const diagnostic = degradedHealthDiagnostic(status);
 	// The health diagnosis leads because gateway, context, and residency facts

package/src/cli/tools.ts

@@ -0,0 +1,321 @@
+import { describeYaziProfile, inspectCurrentYaziProfile, resetYaziProfile } from "../domains/mux/index.js";
+import {
+	describeFloorRejection,
+	describeResolution,
+	findPinnedTool,
+	installedToolVersions,
+	installRemedy,
+	installTool,
+	PINNED_TOOLS,
+	removeTool,
+	type ToolStatus,
+	toolStatus,
+	toolStatuses,
+} from "../domains/toolchain/index.js";
+import { formatColumns, printError, printOk } from "./shared.js";
+
+const HELP = `clio-coder tools <command>
+
+Manage the external terminal programs Clio can drive. Every one of them is
+optional: Clio works without them and only uses one when it is present. Each is
+pinned to an exact upstream version and checksum, and a copy already on PATH
+wins over Clio's own as long as it clears the pinned minimum.
+
+Commands:
+  clio-coder tools list [--json]           the pinned table and where each resolves
+  clio-coder tools status <id> [--json] [--reset-profile]  one tool in detail
+  clio-coder tools install <id> [--force] [--json]  download, verify, and vendor a tool
+  clio-coder tools remove <id>|--all [--json]  delete every vendored version of a tool
+
+Downloads happen only here. Nothing on a startup path fetches anything.
+
+An install keeps one version directory per tool: once the pinned version is in
+place, versions it superseded are pruned, along with any staging directory left
+by an install that was killed. Removal touches nothing outside <data>/tools/<id>
+and needs no confirmation, since every byte under it is re-downloadable from the
+checksum-pinned registry. "remove --all" sweeps every tool in the table.
+`;
+
+interface Parsed {
+	command?: string;
+	positional: string[];
+	json: boolean;
+	force: boolean;
+	all: boolean;
+	resetProfile: boolean;
+	help: boolean;
+}
+
+export async function runToolsCommand(argv: ReadonlyArray<string> = []): Promise<number> {
+	let parsed: Parsed;
+	try {
+		parsed = parse(argv);
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		process.stderr.write(HELP);
+		return 2;
+	}
+	if (parsed.help || parsed.command === undefined) {
+		process.stdout.write(HELP);
+		return parsed.help ? 0 : 2;
+	}
+
+	// `--all` belongs to `remove` alone. Silently ignoring it elsewhere would let
+	// `tools install --all` read as a request that was honored.
+	if (parsed.all && parsed.command !== "remove") {
+		printError("--all is only valid with `tools remove`");
+		return 2;
+	}
+
+	switch (parsed.command) {
+		case "list":
+			if (parsed.resetProfile) return invalidResetProfile();
+			return listTools(parsed.json);
+		case "status":
+			return statusTool(parsed.positional[0], parsed.json, parsed.resetProfile);
+		case "install":
+			if (parsed.resetProfile) return invalidResetProfile();
+			return installOne(parsed.positional[0], parsed.force, parsed.json);
+		case "remove":
+			if (parsed.resetProfile) return invalidResetProfile();
+			return parsed.all ? removeAll(parsed.positional[0], parsed.json) : removeOne(parsed.positional[0], parsed.json);
+		default:
+			printError(`unknown tools command: ${parsed.command}`);
+			process.stderr.write(HELP);
+			return 2;
+	}
+}
+
+function parse(argv: ReadonlyArray<string>): Parsed {
+	const out: Parsed = { positional: [], json: false, force: false, all: false, resetProfile: false, help: false };
+	for (const arg of argv) {
+		if (!out.command && !arg.startsWith("-")) {
+			out.command = arg;
+			continue;
+		}
+		switch (arg) {
+			case "--json":
+				out.json = true;
+				break;
+			case "--force":
+			case "-f":
+				out.force = true;
+				break;
+			case "--all":
+				out.all = true;
+				break;
+			case "--reset-profile":
+				out.resetProfile = true;
+				break;
+			case "--help":
+			case "-h":
+				out.help = true;
+				break;
+			default:
+				if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+				out.positional.push(arg);
+		}
+	}
+	return out;
+}
+
+function listTools(json: boolean): number {
+	const statuses = toolStatuses();
+	if (json) {
+		process.stdout.write(`${JSON.stringify(statuses.map(jsonShape), null, 2)}\n`);
+		return 0;
+	}
+	const rows = statuses.map((status) => [
+		status.id,
+		status.version,
+		status.license,
+		status.resolution.source,
+		describeResolution(status),
+	]);
+	process.stdout.write(formatColumns([["TOOL", "PIN", "LICENSE", "SOURCE", "RESOLVED"], ...rows]));
+	return 0;
+}
+
+function invalidResetProfile(): number {
+	printError("--reset-profile is only valid with `tools status yazi`");
+	return 2;
+}
+
+/**
+ * The one refusal an unknown id gets, from every verb.
+ *
+ * It names the tools that do exist, because the whole error an operator makes
+ * here is a name: `tools remove herd` and `tools remove tmux` want different
+ * answers, and the registry list gives both of them one.
+ */
+function unknownTool(id: string): number {
+	printError(`unknown tool: ${id} (known: ${PINNED_TOOLS.map((row) => row.id).join(", ")})`);
+	return 2;
+}
+
+function statusTool(id: string | undefined, json: boolean, resetProfile: boolean): number {
+	if (id === undefined) {
+		printError("usage: clio-coder tools status <id>");
+		return 2;
+	}
+	const entry = findPinnedTool(id);
+	if (entry === null) {
+		return unknownTool(id);
+	}
+	if (resetProfile && id !== "yazi") return invalidResetProfile();
+	if (resetProfile) resetYaziProfile();
+	const status = toolStatus(entry);
+	const profile = id === "yazi" ? inspectCurrentYaziProfile() : null;
+	if (json) {
+		process.stdout.write(
+			`${JSON.stringify({ ...jsonShape(status), ...(profile ? { profile, profileReset: resetProfile } : {}) }, null, 2)}\n`,
+		);
+		return 0;
+	}
+	const rejection = describeFloorRejection(status);
+	const installedVersions = installedToolVersions(entry.id);
+	const lines = [
+		`${entry.id} ${entry.version} (${entry.license})`,
+		`  ${entry.summary}`,
+		`  homepage    ${entry.homepage}`,
+		`  binaries    ${entry.binaries.join(", ")}`,
+		`  PATH floor  ${entry.minimumVersion}`,
+		`  platform    ${status.platform ?? `${process.platform}-${process.arch}`}${status.supported ? "" : " (no pinned asset)"}`,
+		`  vendor dir  ${status.installDir}${status.installed ? "" : " (not installed)"}`,
+		`  vendored    ${installedVersions.length === 0 ? "nothing" : installedVersions.join(", ")}`,
+		`  resolves to ${describeResolution(status)}`,
+		// Spelled out on its own line as well as inside the resolution sentence,
+		// because a rejected PATH copy is the one thing an operator reads this
+		// command to understand and the sentence above may be about something else.
+		...(rejection === null
+			? []
+			: [
+					`  floor       rejected: ${rejection}`,
+					...(status.resolution.source === "none" && status.supported ? [`  remedy      ${installRemedy(entry.id)}`] : []),
+				]),
+		...(profile
+			? [
+					`  profile     ${describeYaziProfile(profile)}`,
+					...(resetProfile ? ["  profile reset; next open regenerates it"] : []),
+				]
+			: []),
+	];
+	process.stdout.write(`${lines.join("\n")}\n`);
+	return 0;
+}
+
+async function installOne(id: string | undefined, force: boolean, json: boolean): Promise<number> {
+	if (id === undefined) {
+		printError("usage: clio-coder tools install <id>");
+		return 2;
+	}
+	if (findPinnedTool(id) === null) {
+		return unknownTool(id);
+	}
+	const result = await installTool(id, {
+		force,
+		...(json ? {} : { onProgress: (message: string) => process.stderr.write(`  ${message}\n`) }),
+	});
+	if (json) {
+		process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		return result.ok ? 0 : 1;
+	}
+	if (!result.ok) {
+		printError(result.message);
+		return 1;
+	}
+	printOk(result.message);
+	for (const path of result.documents) process.stdout.write(`  license  ${path}\n`);
+	for (const version of result.pruned) process.stdout.write(`  pruned   ${id} ${version}\n`);
+	return 0;
+}
+
+/**
+ * Delete a tool's vendored install.
+ *
+ * The two answers an operator can act on are "there was nothing there" and
+ * "these versions are gone", and both are exit 0: the state they asked for
+ * holds either way. Only an id the registry does not know is a usage error,
+ * because that is the one case where nothing was inspected at all.
+ */
+function removeOne(id: string | undefined, json: boolean): number {
+	if (id === undefined) {
+		printError("usage: clio-coder tools remove <id>");
+		return 2;
+	}
+	if (findPinnedTool(id) === null) return unknownTool(id);
+	const result = removeTool(id);
+	if (json) {
+		process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		return result.ok ? 0 : 1;
+	}
+	if (!result.ok) {
+		printError(result.message);
+		return 1;
+	}
+	printOk(result.message);
+	if (result.removed.length > 0) {
+		process.stdout.write(`  reinstall with \`${installRemedy(id)}\`\n`);
+	}
+	return 0;
+}
+
+/**
+ * Delete every pinned tool's vendored install.
+ *
+ * Each tool is swept independently and the exit code is the worst of them, so
+ * one directory that resists deletion does not hide the two that came off
+ * cleanly. Tools that had nothing installed are counted rather than listed:
+ * on the machine this verb is for, most of the registry is usually absent, and
+ * three lines of "nothing to remove" would bury the one line that matters.
+ */
+function removeAll(id: string | undefined, json: boolean): number {
+	if (id !== undefined) {
+		printError("`tools remove --all` takes no tool id; drop the id or drop --all");
+		return 2;
+	}
+	const results = PINNED_TOOLS.map((entry) => removeTool(entry.id));
+	if (json) {
+		process.stdout.write(`${JSON.stringify(results, null, 2)}\n`);
+		return results.every((result) => result.ok) ? 0 : 1;
+	}
+	for (const result of results) {
+		if (!result.ok) printError(result.message);
+		else if (result.removed.length > 0 || result.staleStaging.length > 0) printOk(result.message);
+	}
+	const touched = results.filter((result) => result.ok && result.removed.length > 0);
+	const untouched = results.filter((result) => result.ok && result.removed.length === 0);
+	if (touched.length > 0) {
+		process.stdout.write(`  reinstall with \`clio-coder tools install <id>\`\n`);
+	}
+	if (untouched.length > 0) {
+		process.stdout.write(`  ${untouched.length} of ${results.length} had nothing vendored\n`);
+	}
+	return results.every((result) => result.ok) ? 0 : 1;
+}
+
+/** The JSON surface, flattened so a script does not have to walk the resolution. */
+function jsonShape(status: ToolStatus): Record<string, unknown> {
+	return {
+		id: status.id,
+		version: status.version,
+		license: status.license,
+		platform: status.platform,
+		supported: status.supported,
+		installed: status.installed,
+		installDir: status.installDir,
+		source: status.resolution.source,
+		binaryPath: status.resolution.binaryPath,
+		foundVersion: status.resolution.version,
+		minimumVersion: status.resolution.entry?.minimumVersion ?? null,
+		pathCandidate: status.resolution.pathCandidate,
+		// A script deciding whether to warn about a floor rejection should not have
+		// to parse `detail` for it, so the rejection and the command that answers
+		// it are their own fields. `remedy` is null exactly where installing would
+		// change nothing: already vendored, or no asset for this platform.
+		floorRejection: describeFloorRejection(status),
+		remedy: status.resolution.source === "none" && status.supported ? installRemedy(status.id) : null,
+		installedVersions: installedToolVersions(status.id),
+		detail: describeResolution(status),
+	};
+}