agent-transport-system 0.7.26 → 0.7.28

package/dist/ats.js

@@ -27,7 +27,7 @@ import wrapAnsi from "wrap-ansi";
 import { Box, Container, Editor, Key, ProcessTerminal, TUI, Text, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
 
 //#region package.json
-var version = "0.7.26";
+var version = "0.7.28";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -5459,7 +5459,7 @@ async function getRemoteAuthSessionState(session) {
 }
 function resolveRemoteSessionTimeoutMs(endpoint) {
 	const url = parseUrlOrNull$3(endpoint);
-	if (url && isLoopbackHostname$3(url.hostname)) return LOOPBACK_REMOTE_SESSION_TIMEOUT_MS;
+	if (url && isLoopbackHostname$4(url.hostname)) return LOOPBACK_REMOTE_SESSION_TIMEOUT_MS;
 	return DEFAULT_REMOTE_SESSION_TIMEOUT_MS;
 }
 function parseUrlOrNull$3(value) {
@@ -5469,7 +5469,7 @@ function parseUrlOrNull$3(value) {
 		return null;
 	}
 }
-function isLoopbackHostname$3(hostname) {
+function isLoopbackHostname$4(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
 }
 function hasActiveSessionPayload(payload) {
@@ -5762,7 +5762,7 @@ async function requireAtsProfilesSession() {
 }
 function resolveAtsProfilesApiTimeoutMs(endpoint) {
 	const url = parseUrlOrNull$2(endpoint);
-	if (url && isLoopbackHostname$2(url.hostname)) return LOOPBACK_ATS_PROFILES_API_TIMEOUT_MS;
+	if (url && isLoopbackHostname$3(url.hostname)) return LOOPBACK_ATS_PROFILES_API_TIMEOUT_MS;
 	return DEFAULT_ATS_PROFILES_API_TIMEOUT_MS;
 }
 function parseUrlOrNull$2(value) {
@@ -5772,7 +5772,7 @@ function parseUrlOrNull$2(value) {
 		return null;
 	}
 }
-function isLoopbackHostname$2(hostname) {
+function isLoopbackHostname$3(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
 }
 function isSameStoredAuthSession(a, b) {
@@ -5908,11 +5908,11 @@ async function findAtsProfileByNameOrHandle(input) {
 }
 function isLoopbackProfileEndpoint(endpoint) {
 	const url = parseUrlOrNull$2(endpoint);
-	return Boolean(url && isLoopbackHostname$2(url.hostname) && url.pathname.startsWith("/v1/profiles"));
+	return Boolean(url && isLoopbackHostname$3(url.hostname) && url.pathname.startsWith("/v1/profiles"));
 }
 function isHostedProfilesEndpoint(endpoint) {
 	const url = parseUrlOrNull$2(endpoint);
-	return Boolean(url && !isLoopbackHostname$2(url.hostname) && url.pathname.startsWith("/v1/profiles"));
+	return Boolean(url && !isLoopbackHostname$3(url.hostname) && url.pathname.startsWith("/v1/profiles"));
 }
 function isRecord$5(value) {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -12214,7 +12214,7 @@ function resolveAuthRequestCompatibility(input) {
 	const expectedGatewayHost = deriveGatewayHost(authBaseUrl);
 	const requestHost = requestUrl.host;
 	const authHost = authBaseUrl.host;
-	if (isLoopbackHostname$1(requestUrl.hostname) && isLoopbackHostname$1(authBaseUrl.hostname)) return {
+	if (isLoopbackHostname$2(requestUrl.hostname) && isLoopbackHostname$2(authBaseUrl.hostname)) return {
 		compatible: true,
 		reason: "loopback",
 		requestHost,
@@ -12278,7 +12278,7 @@ function parseUrlOrNull$1(value) {
 		return null;
 	}
 }
-function isLoopbackHostname$1(hostname) {
+function isLoopbackHostname$2(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
 }
 function isSecureTransportProtocol(protocol) {
@@ -45864,6 +45864,7 @@ function renderDaemonReinstallCard(input) {
 }
 function renderDaemonReinstallOutcome(input) {
 	emitDaemonReinstallResult(input);
+	if (input.suppressHumanResultCard === true) return;
 	renderDaemonReinstallCard(input);
 }
 function createDaemonStartSpinner(input) {
@@ -46180,7 +46181,8 @@ async function runDaemonReinstall(input, options = {}) {
 					action: displayAction,
 					outcome,
 					presenter,
-					resolvedView: runtime.resolvedView
+					resolvedView: runtime.resolvedView,
+					suppressHumanResultCard: options.suppressHumanResultCard
 				});
 				return outcome;
 			} catch (error) {
@@ -50171,6 +50173,7 @@ async function runDaemonServiceParticipationInstallAction(input) {
 		await runDaemonServiceSafeRefresh({
 			atsProfileId: input.input.atsProfileId,
 			gatewayUrl: input.input.gatewayUrl,
+			suppressHumanResultCard: input.input.suppressRefreshHumanResultCard,
 			view: input.input.view
 		});
 		return;
@@ -50210,6 +50213,7 @@ async function runDaemonServiceSafeRefresh(input) {
 		skipConfirm: true,
 		startAfterInstallMode: "always",
 		suppressAgentOverview: true,
+		suppressHumanResultCard: input.suppressHumanResultCard,
 		suppressInstallOutput: true
 	});
 }
@@ -50249,6 +50253,7 @@ async function runDaemonServiceParticipationRefresh(input) {
 		const refreshOutcome = await runDaemonServiceSafeRefresh({
 			atsProfileId: input.input.atsProfileId,
 			gatewayUrl: input.input.gatewayUrl,
+			suppressHumanResultCard: input.input.suppressRefreshHumanResultCard,
 			view: input.input.view
 		});
 		if (refreshOutcome.ok && (refreshOutcome.result === "completed" || refreshOutcome.result === "stopped_safe") && refreshOutcome.serviceState === "stopped") {
@@ -76090,7 +76095,7 @@ function toAuthEndpoint(baseUrl, pathname) {
 }
 function buildSpaceWebUrl(baseUrl, spaceId) {
 	const url = new URL(baseUrl);
-	if (isLoopbackHostname(url.hostname) && url.port === "8080") url.port = "3000";
+	if (isLoopbackHostname$1(url.hostname) && url.port === "8080") url.port = "3000";
 	if (url.hostname === "gateway.ats.sh") {
 		url.hostname = "ats.sh";
 		url.port = "";
@@ -76103,7 +76108,7 @@ function buildSpaceWebUrl(baseUrl, spaceId) {
 }
 function resolveSpaceCreateAuthCheckTimeoutMs(endpoint) {
 	const url = parseUrlOrNull(endpoint);
-	if (url && isLoopbackHostname(url.hostname)) return SPACE_CREATE_AUTH_CHECK_LOOPBACK_TIMEOUT_MS;
+	if (url && isLoopbackHostname$1(url.hostname)) return SPACE_CREATE_AUTH_CHECK_LOOPBACK_TIMEOUT_MS;
 	return SPACE_CREATE_AUTH_CHECK_TIMEOUT_MS;
 }
 function parseUrlOrNull(value) {
@@ -76113,7 +76118,7 @@ function parseUrlOrNull(value) {
 		return null;
 	}
 }
-function isLoopbackHostname(hostname) {
+function isLoopbackHostname$1(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
 }
 function emitSpaceCreateSuccessOutput(input) {
@@ -87272,6 +87277,67 @@ function normalizeId(value) {
 	return value.trim();
 }
 
+//#endregion
+//#region src/ui/setup-human-view.ts
+async function runWithSetupSpinner(input) {
+	const spinner = createDelayedSpinner({
+		enabled: input.enabled,
+		message: input.message
+	});
+	spinner.start();
+	try {
+		const result = await input.run();
+		spinner.complete();
+		return result;
+	} catch (error) {
+		spinner.fail();
+		throw error;
+	}
+}
+function emitSetupHumanHeader(input) {
+	if (input.view !== "human") return;
+	input.presenter.line({
+		code: "setup.header.spacing.start",
+		text: ""
+	});
+	for (const line of renderAtsBrandBlockLines()) input.presenter.line({
+		code: "setup.header.brand",
+		text: line
+	});
+	input.presenter.line({
+		code: "setup.header.spacing.end",
+		text: ""
+	});
+}
+function renderSetupStepCard(input) {
+	if (input.view !== "human") return;
+	renderInfoCard({
+		presenter: input.presenter,
+		title: input.title,
+		codePrefix: input.codePrefix,
+		rows: input.rows,
+		sanitize: true,
+		minContentWidth: 52
+	});
+}
+function renderSetupAgentHandoffCard(input) {
+	if (input.view !== "human") return;
+	renderInfoCard({
+		presenter: input.presenter,
+		title: "For AI Setup Agents",
+		codePrefix: "setup.complete.agent_handoff.card",
+		rows: [{
+			label: "Structured output",
+			value: `Run ${formatAtsCliCommand(`${input.cliCommandPrefix} setup --view agent`)} to print setup.complete.`
+		}, {
+			label: "Use when",
+			value: "An AI setup agent needs the machine-readable setup facts for follow-up ATS commands."
+		}],
+		sanitize: true,
+		minContentWidth: 52
+	});
+}
+
 //#endregion
 //#region src/start-foundation/profile-id.ts
 function resolveCliStartFoundationProfileId(profile) {
@@ -87629,6 +87695,7 @@ const PREPARE_SESSION_MAX_RECONNECT_ATTEMPTS = 3;
 const PREPARE_SESSION_RECONNECT_DELAY_MS = 1e3;
 const REPORT_RUNTIME_CONNECTION_MAX_ATTEMPTS = 12;
 const REPORT_RUNTIME_CONNECTION_RETRY_DELAY_MS = 1e3;
+const BRING_AGENTS_AGENT_SELECTION_PATH = "/app/start/bring-agents/agents";
 const TERMINAL_PREPARE_STEP_ORDER = [
 	"prepare_selected_agents",
 	"refresh_service",
@@ -87761,14 +87828,82 @@ async function resolveAgentSelection(input) {
 		});
 	}
 	if (hasAgentSelectionBeenSaved(input.snapshot)) return input.snapshot;
-	emitHumanStatus(input.input, "Waiting for ATS Web", ["Choose local agents on the setup page.", "Setup will continue here automatically."]);
+	const setupPageUrl = buildPrepareSessionWebSelectionUrl({
+		gatewayUrl: input.input.gatewayUrl,
+		snapshot: input.snapshot
+	});
+	const openedSetupPage = await tryOpenPrepareSessionWebSelectionUrl({
+		input: input.input,
+		setupPageUrl
+	});
+	emitHumanStatus(input.input, "Waiting for ATS Web", [
+		"Choose local agents on the setup page.",
+		...formatPrepareSessionWebSelectionUrlLines({
+			opened: openedSetupPage,
+			setupPageUrl
+		}),
+		"Setup will continue here automatically."
+	]);
 	return await waitForSnapshotWithProgress({
 		input: input.input,
 		stream: input.stream,
 		predicate: hasAgentSelectionBeenSaved,
-		waitingMessage: "Still waiting for your choice in ATS Web. Keep this Terminal open"
+		waitingMessage: formatPrepareSessionWebSelectionWaitingMessage({ setupPageUrl })
 	});
 }
+function buildPrepareSessionWebSelectionUrl(input) {
+	const webBaseUrl = resolvePrepareSessionWebBaseUrl(input.gatewayUrl);
+	if (!webBaseUrl) return null;
+	const url = new URL(BRING_AGENTS_AGENT_SELECTION_PATH, webBaseUrl);
+	url.search = buildPrepareSessionWebSelectionSearch(input.snapshot).toString();
+	return url.toString();
+}
+function buildPrepareSessionWebSelectionSearch(snapshot) {
+	const params = new URLSearchParams();
+	params.set("setup", "this-computer");
+	if (snapshot.targetSpaceId && snapshot.humanProfileId) {
+		params.set("returnTo", "space");
+		params.set("spaceId", snapshot.targetSpaceId);
+		params.set("profileId", snapshot.humanProfileId);
+		return params;
+	}
+	params.set("returnTo", "agents");
+	return params;
+}
+function resolvePrepareSessionWebBaseUrl(gatewayUrl) {
+	try {
+		const url = new URL(gatewayUrl);
+		if (isLoopbackHostname(url.hostname) && url.port === "8080") url.port = "3000";
+		if (url.hostname === "gateway.ats.sh") {
+			url.hostname = "ats.sh";
+			url.port = "";
+			url.protocol = "https:";
+		}
+		url.pathname = "/";
+		url.search = "";
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+function isLoopbackHostname(hostname) {
+	const normalizedHostname = hostname.toLowerCase();
+	return normalizedHostname === "localhost" || normalizedHostname === "127.0.0.1" || normalizedHostname === "::1";
+}
+async function tryOpenPrepareSessionWebSelectionUrl(input) {
+	if (!(input.setupPageUrl && input.input.runtime.resolvedView === "human" && input.input.interactive && process$1.stdout.isTTY)) return false;
+	return await tryOpenUrl(input.setupPageUrl);
+}
+function formatPrepareSessionWebSelectionUrlLines(input) {
+	if (!input.setupPageUrl) return ["Return to ATS Web to finish choosing agents."];
+	if (input.opened) return ["ATS opened the setup page in your browser.", `Setup page: ${input.setupPageUrl}`];
+	return [`Open this setup page: ${input.setupPageUrl}`];
+}
+function formatPrepareSessionWebSelectionWaitingMessage(input) {
+	const baseMessage = "Still waiting for your choice in ATS Web. Keep this Terminal open";
+	return input.setupPageUrl ? `${baseMessage}. Setup page: ${input.setupPageUrl}` : baseMessage;
+}
 function resolveTerminalSelectedLocalAgentIds(input) {
 	if (input.selection.mode === "none") return [];
 	const catalog = input.snapshot.localAgentCatalog;
@@ -91325,6 +91460,10 @@ async function runSetupUnlocked(input) {
 	const presenter = createPresenter(runtime);
 	const interactive = canUseInteractivePrompts(runtime);
 	const gatewayUrl = await resolveBaseUrl();
+	emitSetupHumanHeader({
+		presenter,
+		view: runtime.resolvedView
+	});
 	await maybeLogInWithOneTimeToken({
 		ott: input.ott,
 		view: input.view
@@ -91335,28 +91474,51 @@ async function runSetupUnlocked(input) {
 		promptMessage: "Sign in to ATS before setting up this computer.",
 		allowPrompt: interactive
 	})) return;
-	emitSetupStatus(runtime, "Checking local agents", ["Looking for supported local agents on this computer."]);
-	const initialReadiness = await collectStartLocalReadiness({ auth: {
-		status: "valid",
-		email: null,
-		authBaseUrl: null,
-		gatewayUrl
-	} });
+	const initialReadiness = await runWithSetupSpinner({
+		enabled: runtime.resolvedView === "human",
+		message: "Checking local agents...",
+		run: async () => await collectStartLocalReadiness({ auth: {
+			status: "valid",
+			email: null,
+			authBaseUrl: null,
+			gatewayUrl
+		} })
+	});
 	const selectedLocalAgentIds = resolveSetupLocalAgentIds({
 		localAgent: input.localAgent,
 		localAgents: input.localAgents,
 		readiness: initialReadiness
 	});
-	if (selectedLocalAgentIds.length > 0) {
-		emitSetupStatus(runtime, "Connecting local agents", [`Connecting ${selectedLocalAgentIds.length} local agent${selectedLocalAgentIds.length === 1 ? "" : "s"} for ATS.`]);
-		assertStartLocalAgentsEnableCompleted(await runStartLocalAgentsEnable({
+	if (selectedLocalAgentIds.length > 0) assertStartLocalAgentsEnableCompleted(await runWithSetupSpinner({
+		enabled: runtime.resolvedView === "human",
+		message: "Connecting local agents...",
+		run: async () => await runStartLocalAgentsEnable({
 			agent: selectedLocalAgentIds,
 			interactive,
 			presentation: "handoff",
 			view: input.view
-		}));
-	}
-	emitSetupStatus(runtime, "Starting ATS Service", ["Starting or repairing ATS Service for this computer."]);
+		})
+	}));
+	renderSetupStepCard({
+		presenter,
+		view: runtime.resolvedView,
+		title: "✓ Local Agents",
+		codePrefix: "setup.local_agents.card",
+		rows: [
+			{
+				label: "Status",
+				value: selectedLocalAgentIds.length > 0 ? "Connected" : "No local agents selected"
+			},
+			{
+				label: "Found",
+				value: formatSetupLocalAgentCandidateCount(initialReadiness)
+			},
+			{
+				label: "Selected",
+				value: formatSetupCompleteLocalAgents(selectedLocalAgentIds)
+			}
+		]
+	});
 	const serviceGate = await runDaemonServiceParticipationGate({
 		intent: "start",
 		presenter,
@@ -91366,11 +91528,36 @@ async function runSetupUnlocked(input) {
 		gatewayUrl,
 		forcePrompt: true,
 		refreshIfAuthSessionChanged: true,
+		suppressRefreshHumanResultCard: true,
 		view: input.view
 	});
 	if (serviceGate.status === "cancelled") return;
 	if (serviceGate.status !== "aligned") throw new Error(serviceGate.errorMessage ?? "ATS Service could not be started for setup on this computer.");
 	const atsServiceRuntimeIdentity = await syncLocalSetupCurrentDeviceTargetFromServiceContract({ gatewayUrl });
+	renderSetupStepCard({
+		presenter,
+		view: runtime.resolvedView,
+		title: "✓ ATS Service",
+		codePrefix: "setup.service.card",
+		rows: [
+			{
+				label: "Status",
+				value: "Connected"
+			},
+			{
+				label: "What happened",
+				value: "ATS checked the background service and aligned it with this setup."
+			},
+			{
+				label: "Current service",
+				value: formatSetupCompleteService(atsServiceRuntimeIdentity)
+			},
+			{
+				label: "Next",
+				value: "No action is required."
+			}
+		]
+	});
 	const finalReadiness = await collectStartLocalReadiness({ auth: {
 		status: "valid",
 		email: null,
@@ -91387,8 +91574,31 @@ async function runSetupUnlocked(input) {
 	});
 	assertSelectedLocalRuntimeReportsAccepted(runtimeReports);
 	const routeCatalogSync = selectedLocalAgentIds.length > 0 ? await notifyRouteCatalogAfterSetup({ reason: "setup_local_capabilities_reported" }) : null;
-	emitSetupStatus(runtime, "Updating ATS skills", ["Updating ATS skills so local agents use the current ATS instructions."]);
-	await ensureSetupManagedSkills({ view: input.view });
+	await runWithSetupSpinner({
+		enabled: runtime.resolvedView === "human",
+		message: "Updating ATS skills...",
+		run: async () => await ensureSetupManagedSkills({ view: input.view })
+	});
+	renderSetupStepCard({
+		presenter,
+		view: runtime.resolvedView,
+		title: "✓ ATS Skills",
+		codePrefix: "setup.skills.card",
+		rows: [
+			{
+				label: "Status",
+				value: "Updated"
+			},
+			{
+				label: "What happened",
+				value: "ATS refreshed the local instructions used by supported agents."
+			},
+			{
+				label: "Next",
+				value: "Local agents can use the current ATS guide."
+			}
+		]
+	});
 	emitSetupComplete({
 		gatewayUrl,
 		localComponents: await finalizeLocalComponentsSetupSnapshot(),
@@ -91466,10 +91676,6 @@ function assertStartLocalAgentsEnableCompleted(result) {
 async function notifyRouteCatalogAfterSetup(input) {
 	return await notifyDaemonRouteCatalogChanged({ reason: input.reason });
 }
-function emitSetupStatus(runtime, title, lines) {
-	if (runtime.resolvedView !== "human") return;
-	console.log([title, ...lines].join("\n"));
-}
 async function emitSetupCompleteForDelegatedPath(input) {
 	const runtime = await resolveRuntimeContext({ view: input.view });
 	const presenter = createPresenter(runtime);
@@ -91589,17 +91795,13 @@ function emitSetupComplete(input) {
 	if (input.view === "human") {
 		renderInfoCard({
 			presenter: input.presenter,
-			title: "ATS Setup Complete",
+			title: "✓ ATS Setup Complete",
 			codePrefix: "setup.complete.card",
 			sanitize: true,
 			rows: [
 				{
-					label: "CLI prefix",
-					value: cliCommandPrefix
-				},
-				{
-					label: "Lane root",
-					value: payload.laneRoot
+					label: "Status",
+					value: "Ready"
 				},
 				{
 					label: "Local agents",
@@ -91613,15 +91815,20 @@ function emitSetupComplete(input) {
 					label: "Service",
 					value: formatSetupCompleteService(input.atsServiceRuntimeIdentity)
 				},
+				{
+					label: "Local components",
+					value: input.localComponents.summaryLabel
+				},
 				{
 					label: "Next",
 					value: nextCommands[1] ?? ""
 				}
 			]
 		});
-		emitHumanSetupCompleteAgentHandoff({
-			payload,
-			presenter: input.presenter
+		renderSetupAgentHandoffCard({
+			cliCommandPrefix,
+			presenter: input.presenter,
+			view: input.view
 		});
 		return;
 	}
@@ -91678,33 +91885,6 @@ async function finalizeLocalComponentsSetupSnapshot() {
 	await writeInstalledLocalComponentsSnapshot({ source: "setup" });
 	return await resolveLocalComponentsStatus();
 }
-function emitHumanSetupCompleteAgentHandoff(input) {
-	input.presenter.line({
-		code: "setup.complete.agent_handoff.heading",
-		text: "Agent handoff: setup.complete"
-	});
-	input.presenter.line({
-		code: "setup.complete.agent_handoff.detail",
-		text: "Your setup agent can read the structured block below for follow-up commands."
-	});
-	input.presenter.line({
-		code: "setup.complete.agent_handoff.begin",
-		text: "-----BEGIN ATS SETUP COMPLETE-----"
-	});
-	const envelope = {
-		type: "result",
-		code: "setup.complete",
-		payload: input.payload
-	};
-	for (const line of JSON.stringify(envelope, null, 2).split("\n")) input.presenter.line({
-		code: "setup.complete.agent_handoff.json",
-		text: line
-	});
-	input.presenter.line({
-		code: "setup.complete.agent_handoff.end",
-		text: "-----END ATS SETUP COMPLETE-----"
-	});
-}
 function formatSetupCompleteLocalAgents(selectedLocalAgentIds) {
 	if (selectedLocalAgentIds.length === 0) return "No local agents selected";
 	return `${selectedLocalAgentIds.length} detected: ${selectedLocalAgentIds.join(", ")}`;
@@ -91720,6 +91900,11 @@ function formatSetupCompleteService(atsServiceRuntimeIdentity) {
 	if (!atsServiceRuntimeIdentity) return "Not connected";
 	return `${atsServiceRuntimeIdentity.runtimeLane} - ${shortenIdentifier(atsServiceRuntimeIdentity.deviceId)}`;
 }
+function formatSetupLocalAgentCandidateCount(readiness) {
+	const supportedCount = readiness.agents.candidates.filter((candidate) => candidate.selectable).length;
+	if (supportedCount === 0) return "No supported local agents found";
+	return `${supportedCount} supported local agent${supportedCount === 1 ? "" : "s"} found`;
+}
 function shortenIdentifier(value) {
 	if (value.length <= 18) return value;
 	return `${value.slice(0, 8)}...${value.slice(-4)}`;