agent-transport-system 0.4.93 → 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.93";
+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;