agent-transport-system 0.4.92 → 0.4.94

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.92";
+var version = "0.4.94";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -8304,7 +8304,7 @@ async function findDaemonDependencyPackageRoot(resolvedEntryPath) {
 	throw new Error(`ATS could not determine the package root for background service dependency entry ${resolvedEntryPath}.`);
 }
 function buildDaemonServiceLauncherSource() {
-	return `import { readFile } from "node:fs/promises";
+	return `import { access, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
 import { spawn } from "node:child_process";
@@ -8329,6 +8329,18 @@ async function readJsonFile(path) {
   }
 }
 
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
 function normalizeInstallState(parsed) {
   if (!parsed || parsed.schema !== INSTALL_STATE_SCHEMA || typeof parsed.daemonVersion !== "string" || parsed.daemonVersion.length === 0) {
     return null;
@@ -8372,6 +8384,94 @@ function normalizeBundleState(parsed) {
   return null;
 }
 
+function normalizeBundlePackageManifest(parsed) {
+  if (!parsed || typeof parsed.version !== "string" || parsed.version.length === 0) {
+    return null;
+  }
+  return {
+    version: parsed.version,
+  };
+}
+
+function uniqueNonEmptyStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+
+async function findFallbackSelfContainedBundle(input) {
+  const directories = await readdir(BUNDLE_ROOT_PATH, { withFileTypes: true }).catch((error) => {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+  const entryScriptRelativePaths = uniqueNonEmptyStrings([
+    input.preferredEntryScriptRelativePath,
+    "dist/ats.js",
+    "dist/ats-dev.js",
+  ]);
+  const candidates = [];
+  for (const directory of directories) {
+    if (!directory.isDirectory()) {
+      continue;
+    }
+    const bundleId = directory.name;
+    const bundlePath = join(BUNDLE_ROOT_PATH, bundleId);
+    const manifest = normalizeBundlePackageManifest(
+      await readJsonFile(join(bundlePath, "package.json"))
+    );
+    if (manifest?.version !== input.installState.daemonVersion) {
+      continue;
+    }
+    for (const entryScriptRelativePath of entryScriptRelativePaths) {
+      const entryPath = join(bundlePath, entryScriptRelativePath);
+      if (!(await pathExists(entryPath))) {
+        continue;
+      }
+      const entryStat = await stat(entryPath).catch(() => null);
+      candidates.push({
+        bundleId,
+        entryPath,
+        entryScriptRelativePath,
+        mtimeMs: entryStat?.mtimeMs ?? 0,
+      });
+      break;
+    }
+  }
+  candidates.sort((a, b) => {
+    if (b.mtimeMs !== a.mtimeMs) {
+      return b.mtimeMs - a.mtimeMs;
+    }
+    return b.bundleId.localeCompare(a.bundleId);
+  });
+  return candidates[0] ?? null;
+}
+
+async function persistFallbackActiveBundleState(input) {
+  const now = new Date().toISOString();
+  const bundleRootPath = join(BUNDLE_ROOT_PATH, input.bundleId);
+  const nextState = {
+    v: 2,
+    schema: ACTIVE_BUNDLE_SCHEMA,
+    bundleId: input.bundleId,
+    daemonVersion: input.installState.daemonVersion,
+    entryScriptRelativePath: input.entryScriptRelativePath,
+    bundleFormat: "self_contained_v1",
+    sourceEntryScriptPath: input.entryPath,
+    sourcePackageRootPath: bundleRootPath,
+    sourceDistRootPath: join(bundleRootPath, "dist"),
+    sourceDistFingerprint: null,
+    sourceKind: "package_install",
+    createdAt: input.previousBundleState?.createdAt ?? now,
+    updatedAt: now,
+  };
+  await writeFile(ACTIVE_BUNDLE_PATH, \`\${JSON.stringify(nextState, null, 2)}\\n\`, {
+    encoding: "utf8",
+    mode: 0o600,
+  }).catch((error) => {
+    console.error(\`ATS Service launcher recovered a matching bundle but could not update active bundle state: \${String(error)}\`);
+  });
+}
+
 async function resolveEntryPath() {
   const installState = normalizeInstallState(await readJsonFile(INSTALL_STATE_PATH));
   const bundleState = normalizeBundleState(await readJsonFile(ACTIVE_BUNDLE_PATH));
@@ -8379,18 +8479,87 @@ async function resolveEntryPath() {
     throw new Error("ATS Service launcher could not read a valid install state.");
   }
   if (!bundleState) {
-    throw new Error("ATS Service launcher could not read a valid active bundle state.");
+    const fallback = await findFallbackSelfContainedBundle({
+      installState,
+      preferredEntryScriptRelativePath: null,
+    });
+    if (!fallback) {
+      throw new Error("ATS Service launcher could not read a valid active bundle state.");
+    }
+    await persistFallbackActiveBundleState({
+      ...fallback,
+      installState,
+      previousBundleState: null,
+    });
+    console.error(\`ATS Service launcher recovered bundle \${fallback.bundleId} because active bundle state was missing or invalid.\`);
+    return fallback.entryPath;
   }
   if (bundleState.bundleFormat !== "self_contained_v1") {
-    throw new Error(\`ATS Service launcher refused to start legacy bundle format \${String(bundleState.bundleFormat)}.\`);
+    const fallback = await findFallbackSelfContainedBundle({
+      installState,
+      preferredEntryScriptRelativePath: bundleState.entryScriptRelativePath,
+    });
+    if (!fallback) {
+      throw new Error(\`ATS Service launcher refused to start legacy bundle format \${String(bundleState.bundleFormat)}.\`);
+    }
+    await persistFallbackActiveBundleState({
+      ...fallback,
+      installState,
+      previousBundleState: bundleState,
+    });
+    console.error(\`ATS Service launcher recovered bundle \${fallback.bundleId} because active bundle state used legacy bundle format \${String(bundleState.bundleFormat)}.\`);
+    return fallback.entryPath;
   }
   if (bundleState.sourceKind === "workspace" && !ALLOW_WORKSPACE_BUNDLE_SOURCE) {
-    throw new Error("ATS Service launcher refused to start a repo-local workspace bundle in this lane. Repo-local service bundles are only allowed through \`ats-dev\`.");
+    const fallback = await findFallbackSelfContainedBundle({
+      installState,
+      preferredEntryScriptRelativePath: bundleState.entryScriptRelativePath,
+    });
+    if (!fallback) {
+      throw new Error("ATS Service launcher refused to start a repo-local workspace bundle in this lane. Repo-local service bundles are only allowed through \`ats-dev\`.");
+    }
+    await persistFallbackActiveBundleState({
+      ...fallback,
+      installState,
+      previousBundleState: bundleState,
+    });
+    console.error(\`ATS Service launcher recovered bundle \${fallback.bundleId} because active bundle state pointed at a repo-local workspace bundle in this lane.\`);
+    return fallback.entryPath;
   }
   if (bundleState.daemonVersion !== installState.daemonVersion) {
-    throw new Error(\`ATS Service launcher detected bundle version drift: bundle v\${String(bundleState.daemonVersion)} != install v\${String(installState.daemonVersion)}.\`);
+    const fallback = await findFallbackSelfContainedBundle({
+      installState,
+      preferredEntryScriptRelativePath: bundleState.entryScriptRelativePath,
+    });
+    if (!fallback) {
+      throw new Error(\`ATS Service launcher detected bundle version drift: bundle v\${String(bundleState.daemonVersion)} != install v\${String(installState.daemonVersion)}.\`);
+    }
+    await persistFallbackActiveBundleState({
+      ...fallback,
+      installState,
+      previousBundleState: bundleState,
+    });
+    console.error(\`ATS Service launcher recovered bundle \${fallback.bundleId} because active bundle state had version drift.\`);
+    return fallback.entryPath;
+  }
+  const entryPath = join(BUNDLE_ROOT_PATH, bundleState.bundleId, bundleState.entryScriptRelativePath);
+  if (await pathExists(entryPath)) {
+    return entryPath;
   }
-  return join(BUNDLE_ROOT_PATH, bundleState.bundleId, bundleState.entryScriptRelativePath);
+  const fallback = await findFallbackSelfContainedBundle({
+    installState,
+    preferredEntryScriptRelativePath: bundleState.entryScriptRelativePath,
+  });
+  if (!fallback) {
+    throw new Error(\`ATS Service launcher could not find active bundle entry \${entryPath}.\`);
+  }
+  await persistFallbackActiveBundleState({
+    ...fallback,
+    installState,
+    previousBundleState: bundleState,
+  });
+  console.error(\`ATS Service launcher recovered bundle \${fallback.bundleId} because active bundle entry was missing.\`);
+  return fallback.entryPath;
 }
 
 async function main() {
@@ -15688,8 +15857,9 @@ function resolvePrimaryAction(input) {
 	if (!input.profile.active || input.profile.source === "unavailable") return "check_status";
 	if (!input.binding.routable) return input.binding.source === "unavailable" || input.binding.source === "not_checked" ? "check_status" : "reconnect_binding";
 	if (!input.service.executionCompatible || hasServiceUpdateRequiredReason(input.service.reasonCodes)) return "update_service";
-	if (!(input.localService.reachable || input.route.online)) return "run_prepare";
 	if (hasServiceUpdateRequiredReason(input.runtime.reasonCodes)) return "update_service";
+	if (hasBindingReconnectReason(input.localService.reasonCodes) || input.claim.executionBlocked && hasBindingReconnectReason(input.claim.reasonCodes)) return "reconnect_binding";
+	if (!(input.localService.reachable || input.route.online)) return "run_prepare";
 	if (!input.runtime.ready) return resolveRuntimeNotReadyPrimaryAction({
 		localService: input.localService,
 		runtime: input.runtime
@@ -15711,9 +15881,15 @@ function resolveBlockedClaimPrimaryAction(input) {
 	];
 	if (hasServiceUpdateRequiredReason(claimAndRuntimeReasonCodes)) return "update_service";
 	if (hasRuntimeCapabilityReportRefreshReason(claimAndRuntimeReasonCodes) && input.localService.refreshable) return "check_status";
+	if (hasBindingReconnectReason(input.claim.reasonCodes)) return "reconnect_binding";
 	if (hasSetupRepairReason(input.claim.reasonCodes)) return "run_prepare";
 	return "run_prepare";
 }
+function hasBindingReconnectReason(reasonCodes) {
+	return reasonCodes.some((reasonCode) => {
+		return reasonCode === "claim_eligibility.binding_capability_mismatch" || reasonCode === "claim_eligibility.binding_owner_mismatch" || reasonCode === "claim_eligibility.binding_runtime_mismatch" || reasonCode === "claim_eligibility.owner_mismatch" || reasonCode === "claim_eligibility.runtime_id_mismatch" || reasonCode === "local_service.identity_mismatch";
+	});
+}
 function resolveRuntimeNotReadyPrimaryAction(input) {
 	if (hasRuntimeCapabilityReportRefreshReason(input.runtime.reasonCodes) && input.localService.refreshable) return "check_status";
 	return "run_prepare";
@@ -52336,8 +52512,9 @@ async function stopRegisteredDaemonServiceManager(input) {
 			runtimeStatus: input.ownerSnapshot.runtimeStatus
 		});
 	}
+	let residualCleanupResult;
 	try {
-		await stopResidualDaemonProcessesAfterManagerStop({
+		residualCleanupResult = await stopResidualDaemonProcessesAfterManagerStop({
 			force: input.force,
 			mode: input.mode,
 			runtimeStatus: input.ownerSnapshot.runtimeStatus
@@ -52350,7 +52527,7 @@ async function stopRegisteredDaemonServiceManager(input) {
 			errorMessage: toErrorMessage$12(error)
 		});
 	}
-	const finalOwnerSnapshot = await readCurrentDaemonOwnerSnapshot();
+	const finalOwnerSnapshot = residualCleanupResult.shouldRefresh ? await readCurrentDaemonOwnerSnapshot() : residualCleanupResult.ownerSnapshot;
 	if (hasActiveDaemonOwners(finalOwnerSnapshot) || finalOwnerSnapshot.serviceManagerStatus?.enabled === true) return buildDaemonStopWarningResult({
 		reason: "stop_failed",
 		runtimeStatus: finalOwnerSnapshot.runtimeStatus,
@@ -52387,6 +52564,10 @@ async function stopResidualDaemonProcessesAfterManagerStop(input) {
 			throw new Error(`Residual ATS-owned process pid=${String(processInfo.pid)} did not exit after ${signal}.`);
 		}
 	}
+	return {
+		ownerSnapshot: residualOwnerSnapshot,
+		shouldRefresh: residualOwnerSnapshot.ownedProcesses.length > 0
+	};
 }
 async function stopCurrentLaneDaemonProcess(input) {
 	const daemonPid = input.runtimeStatus.pid;
@@ -54129,6 +54310,28 @@ async function resolveDaemonServiceParticipationStatus(input) {
 async function runDaemonServiceParticipationGate(input) {
 	if (!shouldRunDaemonServiceParticipationGate(input)) return { status: "aligned" };
 	const initialStatus = await resolveDaemonServiceParticipationStatus();
+	if (isRunningAdvisoryOnlyServiceDrift(initialStatus)) {
+		const accountIssue = await resolveDaemonServiceAccountAlignmentIssue(input);
+		if (!accountIssue) return { status: "aligned" };
+		const codePrefix = resolveDaemonServiceParticipationCodePrefix(input.intent);
+		if (input.autoRepair === true) return await runDaemonServiceParticipationRefresh({
+			input,
+			codePrefix,
+			expectedVersion: initialStatus.expectedVersion,
+			accountIssue
+		});
+		renderDaemonStartNeedsAttention({
+			presenter: input.presenter,
+			codePrefix,
+			summary: accountIssue.summary
+		});
+		input.presenter.line({
+			code: `${codePrefix}.account_alignment_failed`,
+			text: accountIssue.summary,
+			data: { reasonCode: accountIssue.reasonCode }
+		});
+		return { status: "needs_attention" };
+	}
 	if (input.forceRefresh === true && initialStatus.kind === "ready") return await runDaemonServiceParticipationRefresh({
 		input,
 		codePrefix: resolveDaemonServiceParticipationCodePrefix(input.intent),
@@ -54169,6 +54372,9 @@ async function runDaemonServiceParticipationGate(input) {
 		status: installStageResult.status
 	});
 }
+function isRunningAdvisoryOnlyServiceDrift(status) {
+	return status.kind === "needs_repair" && status.runtimeStatus === "running" && status.anomalyCodes.length > 0 && status.anomalyCodes.every((code) => DAEMON_SERVICE_WAKEABILITY_ADVISORY_ANOMALIES.has(code));
+}
 function shouldRunDaemonServiceParticipationGate(input) {
 	return input.resolvedView === "human" && (input.allowPrompt || input.autoRepair === true) && (input.forcePrompt === true || shouldRequireDaemonServiceParticipation(input.localDemand));
 }
@@ -56939,6 +57145,12 @@ const TERMINAL_PREPARE_STEP_ORDER = [
 	"report_runtime",
 	"verify_setup"
 ];
+var PrepareSessionBlockedByCoreError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PrepareSessionBlockedByCoreError";
+	}
+};
 async function runPrepareSessionExecutor(input) {
 	let initial = await resolvePrepareSessionToken({
 		gatewayUrl: input.gatewayUrl,
@@ -57099,11 +57311,18 @@ async function runTerminalStep(input) {
 			stepId: input.stepId,
 			status: "completed"
 		});
-		return await input.stream.waitForSnapshot((snapshot) => {
+		const resolvedSnapshot = await input.stream.waitForSnapshot((snapshot) => {
 			const step = findStep(snapshot, input.stepId);
-			return snapshot.sessionRevision > stepCompleteRevision && step?.state === "complete";
+			return snapshot.sessionRevision > stepCompleteRevision && (step?.state === "complete" || step?.state === "blocked" || snapshot.phase === "blocked" || snapshot.lifecycleStatus !== "active");
 		});
+		assertTerminalStepCompletedOrThrow({
+			input: input.input,
+			snapshot: resolvedSnapshot,
+			stepId: input.stepId
+		});
+		return resolvedSnapshot;
 	} catch (error) {
+		if (error instanceof PrepareSessionBlockedByCoreError) throw error;
 		if (error instanceof PrepareSessionRevisionConflictError) {
 			const message = "This setup changed while Terminal was working. Run the same setup command again to continue from the latest step.";
 			emitHumanStatus(input.input, "Setup changed", [message]);
@@ -57132,6 +57351,13 @@ async function runTerminalStep(input) {
 		throw userFacingError;
 	}
 }
+function assertTerminalStepCompletedOrThrow(input) {
+	if (findStep(input.snapshot, input.stepId)?.state === "complete" && input.snapshot.phase !== "blocked") return;
+	const blocker = input.snapshot.blockers.find((candidate) => candidate.stepId === input.stepId) ?? input.snapshot.blockers[0] ?? null;
+	const message = blocker?.message ?? "ATS setup is blocked. Return to ATS Web for details.";
+	emitHumanStatus(input.input, "Setup blocked", [message, ...blocker?.reasonCode ? [`Support code: ${blocker.reasonCode}`] : []]);
+	throw new PrepareSessionBlockedByCoreError(message);
+}
 function resolveNextTerminalPrepareStep(snapshot) {
 	if (snapshot.selectedLocalAgentIds.length === 0) return null;
 	return TERMINAL_PREPARE_STEP_ORDER.find((stepId) => {