agent-transport-system 0.4.2 → 0.4.3

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.4.2";
+var version = "0.4.3";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -54812,9 +54812,9 @@ function stripAnsi(value) {
 
 //#endregion
 //#region src/system/selected-local-runtime-reporting.ts
-async function submitSelectedLocalRuntimeReports(input) {
+function resolveSelectedLocalRuntimeReadiness(input) {
 	const uniqueAgentIds = [...new Set(input.localAgentIds.map(normalizeId))].filter(Boolean).sort();
-	const results = [];
+	const decisions = [];
 	for (const agentId of uniqueAgentIds) {
 		const capabilityRef = resolveCapabilityRefFromControllerBinding({
 			controllerKind: "builtin",
@@ -54825,18 +54825,26 @@ async function submitSelectedLocalRuntimeReports(input) {
 			candidate: input.readiness.agents.candidates.find((currentCandidate) => currentCandidate.agentId === agentId) ?? null,
 			readiness: input.readiness
 		});
-		results.push({
+		decisions.push({
 			agentId,
 			capabilityRef,
 			localParticipationState: readinessDecision.localParticipationState,
-			reasonCodes: readinessDecision.reasonCodes,
-			runtimeReportSubmission: await submitPrepareRuntimeCapabilityReport({
-				capabilityRef,
-				localParticipationState: readinessDecision.localParticipationState,
-				reasonCodes: readinessDecision.reasonCodes
-			})
+			reasonCodes: readinessDecision.reasonCodes
 		});
 	}
+	return decisions;
+}
+async function submitSelectedLocalRuntimeReports(input) {
+	const decisions = resolveSelectedLocalRuntimeReadiness(input);
+	const results = [];
+	for (const decision of decisions) results.push({
+		...decision,
+		runtimeReportSubmission: await submitPrepareRuntimeCapabilityReport({
+			capabilityRef: decision.capabilityRef,
+			localParticipationState: decision.localParticipationState,
+			reasonCodes: decision.reasonCodes
+		})
+	});
 	return results;
 }
 function assertSelectedLocalRuntimeReportsAccepted(results) {
@@ -54845,6 +54853,11 @@ function assertSelectedLocalRuntimeReportsAccepted(results) {
 	const reasonCode = failed.reasonCodes[0] ?? failed.runtimeReportSubmission.reasonCodes[0] ?? failed.runtimeReportSubmission.reason ?? "runtime.reporting.unavailable";
 	throw new Error(formatSelectedRuntimeReportFailure(failed.agentId, reasonCode));
 }
+function assertSelectedLocalRuntimeReadinessReady(decisions) {
+	const failed = decisions.find((decision) => decision.localParticipationState !== "ready");
+	if (!failed) return;
+	throw new Error(formatSelectedRuntimeReportFailure(failed.agentId, failed.reasonCodes[0] ?? "runtime.reporting.unavailable"));
+}
 function formatSelectedRuntimeReportFailure(agentId, reasonCode) {
 	if (reasonCode === "service.not_running") return `ATS could not connect selected agents to ATS for ${agentId} because ATS Service is not running. Run \`${formatAtsCliCommand("ats service status")}\` to inspect it, then \`${formatAtsCliCommand("ats service run")}\` to start it and retry this Web setup command.`;
 	if (reasonCode === "service.not_installed") return `ATS could not connect selected agents to ATS for ${agentId} because ATS Service is not installed. Run \`${formatAtsCliCommand("ats service install")}\`, then \`${formatAtsCliCommand("ats service run")}\`, and retry this Web setup command.`;
@@ -54975,6 +54988,8 @@ async function syncLocalSetupCurrentDeviceTargetFromServiceContract(input) {
 const PREPARE_TOKEN_HEADER = "x-ats-prepare-token";
 const PREPARE_SESSION_MAX_RECONNECT_ATTEMPTS = 3;
 const PREPARE_SESSION_RECONNECT_DELAY_MS = 1e3;
+const ROUTE_CATALOG_SYNC_MAX_ATTEMPTS = 8;
+const ROUTE_CATALOG_SYNC_RETRY_DELAY_MS = 750;
 const TERMINAL_PREPARE_STEP_ORDER = [
 	"prepare_selected_agents",
 	"refresh_service",
@@ -55233,7 +55248,7 @@ function buildTerminalStep(input) {
 		case "verify_setup": return {
 			message: "Checking that selected local agents are ready.",
 			run: async () => {
-				return await connectSelectedLocalAgentsToAts({
+				return await verifySelectedLocalAgentsConnectedToAts({
 					gatewayUrl: input.input.gatewayUrl,
 					localAgentIds: input.localAgentIds
 				});
@@ -55299,12 +55314,71 @@ async function connectSelectedLocalAgentsToAts(input) {
 		readiness,
 		localAgentIds: input.localAgentIds
 	}));
-	if (input.syncRouteCatalog) await notifyDaemonRouteCatalogChanged({ reason: "prepare_selected_agents_connected" });
+	if (input.syncRouteCatalog) await waitForConfirmedRouteCatalogSync({ reason: "prepare_selected_agents_connected" });
 	return {
 		...runtimeIdentity,
 		localReadinessSnapshot: buildPrepareLocalReadinessSnapshot(readiness)
 	};
 }
+async function verifySelectedLocalAgentsConnectedToAts(input) {
+	const runtimeIdentity = await readTerminalRuntimeIdentityFromServiceContract();
+	const readiness = await collectStartLocalReadiness({ auth: {
+		status: "valid",
+		email: null,
+		authBaseUrl: null,
+		gatewayUrl: input.gatewayUrl
+	} });
+	const selectedReadiness = resolveSelectedLocalRuntimeReadiness({
+		readiness,
+		localAgentIds: input.localAgentIds
+	});
+	assertSelectedLocalRuntimeReadinessReady(selectedReadiness);
+	await assertSelectedRuntimeReadinessIsReadableByAts({
+		gatewayUrl: input.gatewayUrl,
+		runtimeIdentity,
+		selectedReadiness
+	});
+	return {
+		...runtimeIdentity,
+		localReadinessSnapshot: buildPrepareLocalReadinessSnapshot(readiness)
+	};
+}
+async function readTerminalRuntimeIdentityFromServiceContract() {
+	const serviceContract = await readDaemonServiceContract();
+	const deviceId = serviceContract?.deviceId;
+	const runtimeLane = serviceContract?.lane;
+	if (!(deviceId && runtimeLane)) throw new Error("ATS could not verify selected agents because ATS Service did not provide this computer's device identity yet. Keep ATS Service running, then run the same setup command again.");
+	return {
+		deviceId,
+		runtimeLane
+	};
+}
+async function waitForConfirmedRouteCatalogSync(input) {
+	let latestDelivery = null;
+	for (let attempt = 1; attempt <= ROUTE_CATALOG_SYNC_MAX_ATTEMPTS; attempt++) {
+		latestDelivery = await notifyDaemonRouteCatalogChanged({ reason: input.reason });
+		if (latestDelivery.delivery === "control_plane") return latestDelivery;
+		if (attempt < ROUTE_CATALOG_SYNC_MAX_ATTEMPTS) await sleep$1(ROUTE_CATALOG_SYNC_RETRY_DELAY_MS);
+	}
+	throw new Error(formatRouteCatalogSyncFailure(latestDelivery));
+}
+async function assertSelectedRuntimeReadinessIsReadableByAts(input) {
+	const capabilityRefs = input.selectedReadiness.map((decision) => decision.capabilityRef);
+	if (capabilityRefs.length === 0) return;
+	const response = await createPrepareReadinessApi(createCliApiClientFoundation(input.gatewayUrl)).getReadiness({
+		capabilityRefs,
+		deviceId: input.runtimeIdentity.deviceId,
+		lane: input.runtimeIdentity.runtimeLane
+	});
+	const runnableCapabilityRefs = new Set(response.runnableCapabilities.map((capability) => capability.capabilityRef));
+	const missingCapabilityRef = capabilityRefs.find((capabilityRef) => !runnableCapabilityRefs.has(capabilityRef));
+	if (response.status === "ready" && response.runtimeId && !missingCapabilityRef) return;
+	const reasonCode = response.summary.reasonCodes[0] ?? response.reason ?? (missingCapabilityRef ? "prepare_readiness.capability_not_ready" : "prepare_readiness.not_ready");
+	throw new Error(`ATS could not verify that selected agents are connected to ATS yet. Keep ATS Service running, then run the same setup command again. Support code: ${reasonCode}.`);
+}
+function formatRouteCatalogSyncFailure(latestDelivery) {
+	return `ATS Service started, but ATS could not confirm that selected agents are available for Wake yet. Keep ATS Service running, then run the same setup command again. Support code: ${latestDelivery?.delivery === "signal" ? `route_catalog_sync.${latestDelivery.fallbackReason}` : "route_catalog_sync.unavailable"}.`;
+}
 function buildPrepareLocalReadinessSnapshot(readiness) {
 	return {
 		observedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -55493,9 +55567,13 @@ function startHumanWaitingIndicator(input, message) {
 	}
 	let tick = 0;
 	const render = () => {
-		const dots = ".".repeat(tick % 3 + 1);
+		const line = formatHumanWaitingIndicatorLine({
+			message: normalizedMessage,
+			terminalColumns: process$1.stdout.columns,
+			tick
+		});
 		tick += 1;
-		process$1.stdout.write(`\r${normalizedMessage}${dots}   `);
+		process$1.stdout.write(`\r\x1b[2K${line}`);
 	};
 	render();
 	const timer = setInterval(render, 500);
@@ -55504,6 +55582,23 @@ function startHumanWaitingIndicator(input, message) {
 		process$1.stdout.write("\r\x1B[2K");
 	} };
 }
+function formatHumanWaitingIndicatorLine(input) {
+	const label = shortHumanWaitingIndicatorLabel(input.message);
+	const dots = ".".repeat(input.tick % 3 + 1);
+	const maxLength = typeof input.terminalColumns === "number" && input.terminalColumns > 12 ? input.terminalColumns - 1 : 79;
+	return `${truncateTerminalLine(label, Math.max(8, maxLength - dots.length))}${dots}`;
+}
+function shortHumanWaitingIndicatorLabel(message) {
+	const normalizedMessage = message.toLowerCase();
+	if (normalizedMessage.includes("choice in ats web")) return "Waiting for ATS Web";
+	if (normalizedMessage.includes("connecting")) return "Connecting to ATS Web";
+	return message;
+}
+function truncateTerminalLine(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	if (maxLength <= 1) return value.slice(0, maxLength);
+	return `${value.slice(0, maxLength - 1)}.`;
+}
 function toStatusCodeSlug(title) {
 	const slug = title.toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "");
 	return slug.length > 0 ? slug : "status";