@devrouter/cli 0.0.65 → 0.0.67

package/dist/devrouter-lifecycle-worker.js

@@ -1188,6 +1188,17 @@ function inspectDevsyRuntimeStatus(devsyId) {
   if (result.status !== 0 || result.error) return "unknown";
   return parseDevsyRuntimeStatus(result.stdout, devsyId);
 }
+function inspectDevsyRuntimeAbsence(devsyId) {
+  const result = (0, import_node_child_process5.spawnSync)("devsy", ["workspace", "status", devsyId, "--result-format", "json"], {
+    encoding: "utf-8",
+    timeout: 1e4
+  });
+  if (!result.error && result.status === 0) {
+    return parseDevsyRuntimeStatus(result.stdout, devsyId) === "not-found";
+  }
+  const output = [result.error?.message, result.stdout, result.stderr].filter(Boolean).join("\n");
+  return /workspace not found/i.test(output);
+}
 function inspectDevsyWorkspaceOwnership(workspaces, devsyId, worktreePath) {
   const idOwners = workspaces.filter((workspace) => workspace.id === devsyId);
   const pathOwners = workspaces.filter(
@@ -1987,6 +1998,7 @@ function requireReadyDevsyAgent(options = {}) {
 // src/core/managed-devsy-stop.ts
 var import_node_os4 = __toESM(require("os"));
 var import_node_path20 = __toESM(require("path"));
+var import_node_util4 = require("util");
 
 // src/core/devcontainer-profile.ts
 var import_node_child_process10 = require("child_process");
@@ -3202,7 +3214,16 @@ function registration(state) {
       throw new Error("Stop workspace identity changed.");
     resolveGitCommonDir(state.repoPath);
   } else if (state.workspace !== void 0) throw new Error("Stop checkout identity changed.");
-  const value = owner.workspace;
+  return identityOf(owner.workspace);
+}
+function managedRunnerId(uid, providerId) {
+  if (uid === void 0) {
+    return providerId;
+  }
+  const bytes = Buffer.byteLength(uid);
+  return bytes === 16 || bytes === 40 ? uid : providerId;
+}
+function identityOf(value) {
   return {
     context: value.context ?? "",
     providerId: value.id,
@@ -3347,6 +3368,64 @@ function absentRegistrationIdentity(state) {
   }
   return { record: record5, gitCommonDir: resolveGitCommonDir(state.repoPath) };
 }
+function replacementObservation(state) {
+  resetWorkspaceRuntimeCaches();
+  if (resolveWorkspaceRuntimeOrDefault(state.repoPath) !== "devsy")
+    throw new Error("Stop provider changed.");
+  if (!state.workspace || !isLinkedWorktree(state.repoPath))
+    throw new Error("Replacement stop requires a linked workspace.");
+  const record5 = readWorkspaceOwnership(state.repoPath, state.workspace);
+  if (!record5 || record5.workspace !== state.workspace || record5.devpodId !== state.devpodId || !sameWorkspacePath(record5.worktreePath, state.repoPath) || resolveWorktreeWorkspace(state.repoPath) !== state.workspace || inspectWorkspaceOwnership(record5, listGitWorktrees(state.repoPath), void 0).ownerStatus !== "present")
+    throw new Error("Replacement stop workspace ownership changed.");
+  const owner = inspectDevsyWorkspaceOwnership(
+    listDevsyWorkspaces(),
+    state.devpodId,
+    state.repoPath
+  );
+  if (owner.status !== "owned")
+    throw new Error("Replacement stop requires one exact provider registration.");
+  if (listDevpodWorkspacesRaw({ allowMissingExecutable: true }).some(
+    (entry) => entry.id === state.devpodId || sameWorkspacePath(entry.source.localFolder, state.repoPath)
+  ))
+    throw new Error("Replacement stop requires no competing provider registration.");
+  proveLocalDockerSelection(owner.workspace);
+  return owner.workspace;
+}
+function proveReplacementStopAbsence(state, baseline, replacement) {
+  const observation = () => {
+    const workspace = replacementObservation(state);
+    if (workspace.uid !== replacement.uid)
+      throw new Error("Replacement stop registration changed during inspection.");
+    if (resolveManagedStopEndpoint() !== baseline.endpoint)
+      throw new Error("Stop endpoint changed.");
+    if (inspectManagedStopDaemon(baseline.endpoint) !== baseline.daemonId)
+      throw new Error("Stop daemon changed.");
+    return workspace;
+  };
+  const before = observation();
+  if (!(0, import_node_util2.isDeepStrictEqual)(readManagedRuntimeState(state.repoPath, state.workspace), state))
+    throw new Error("Retained stop generation changed.");
+  assertManagedStopContainersAbsent(
+    baseline.endpoint,
+    baseline.containers.map((container) => container.id)
+  );
+  const oldRunner = managedRunnerId(baseline.uid, baseline.providerId);
+  const newRunner = managedRunnerId(before.uid, baseline.providerId);
+  const runners = oldRunner === newRunner ? [oldRunner] : [oldRunner, newRunner];
+  const assertEmptyPopulation = () => {
+    if (inspectManagedStopContainers(baseline.project, baseline.endpoint).length !== 0 || inspectManagedStopWorkspaceIds(baseline.endpoint, baseline.composeDirectory).length !== 0 || runners.some((id3) => inspectProviderRunnerContainers(baseline.endpoint, id3).length !== 0))
+      throw new Error("Replacement stop observed a remaining workspace population.");
+  };
+  assertEmptyPopulation();
+  const after = observation();
+  if (after.uid !== before.uid || !(0, import_node_util2.isDeepStrictEqual)(readManagedRuntimeState(state.repoPath, state.workspace), state))
+    throw new Error("Replacement stop authority changed during inspection.");
+  assertManagedStopContainersAbsent(
+    baseline.endpoint,
+    baseline.containers.map((container) => container.id)
+  );
+  assertEmptyPopulation();
+}
 function proveManagedStop(state) {
   const baseline = validateManagedStopBaseline(state.stopBaseline, state);
   const owner = inspectDevsyWorkspaceOwnership(
@@ -3354,6 +3433,15 @@ function proveManagedStop(state) {
     state.devpodId,
     state.repoPath
   );
+  if (owner.status === "owned") {
+    const identityKeys = ["context", "providerId", "uid", "sourcePath", "sourceContainer"];
+    const current = identityOf(owner.workspace);
+    const changed = identityKeys.filter((key) => baseline[key] !== current[key]);
+    if (changed.length === 1 && changed[0] === "uid" && !baseline.sourceContainer && !current.sourceContainer && state.workspace !== void 0 && isLinkedWorktree(state.repoPath)) {
+      proveReplacementStopAbsence(state, baseline, { uid: current.uid || void 0 });
+      return { status: "proven-absent", containers: [] };
+    }
+  }
   if (owner.status !== "absent")
     return { status: "retained", containers: proveRetainedManagedStop(state) };
   if (baseline.sourceContainer) throw new Error("Absent stop cannot prove a source container.");
@@ -4787,7 +4875,7 @@ function loadRepoConfig(repoPath, read2 = (file) => import_node_fs14.default.rea
   const config = parseConfig(parsed ?? {}, configPath);
   const requiredVersion = config.devrouter?.version;
   if (requiredVersion && !hasWarnedVersionMismatch) {
-    const cliVersion = true ? "0.0.65" : "0.0.0-dev";
+    const cliVersion = true ? "0.0.67" : "0.0.0-dev";
     if (cliVersion !== "0.0.0-dev" && compareSemver(requiredVersion, cliVersion) > 0) {
       hasWarnedVersionMismatch = true;
       process.stderr.write(
@@ -5342,6 +5430,66 @@ function stopRetainedManagedDevsyWorkspace(options) {
     }
     return owner.workspace;
   }
+  function registrationStatus() {
+    resetWorkspaceRuntimeCaches();
+    if (resolveWorkspaceRuntimeOrDefault(repoPath) !== "devsy") {
+      throw new Error("Managed stop provider selection changed.");
+    }
+    return inspectDevsyWorkspaceOwnership(listDevsyWorkspaces(), devsyId, repoPath);
+  }
+  function proveAbsentRegistrationStop() {
+    const observe = () => {
+      const owner = registrationStatus();
+      if (owner.status === "conflict") throw new Error(owner.reason);
+      if (owner.status !== "absent") {
+        throw new Error("Managed stop absence proof requires the registration to remain absent.");
+      }
+      if (listDevpodWorkspacesRaw({ allowMissingExecutable: true }).some(
+        (entry) => entry.id === devsyId || sameWorkspacePath(entry.source.localFolder, repoPath)
+      )) {
+        throw new Error(
+          "Managed stop absence proof requires both provider registrations to remain absent."
+        );
+      }
+      if (!inspectDevsyRuntimeAbsence(devsyId)) {
+        throw new Error(
+          "Managed stop absence proof requires Devsy to report the runtime not-found."
+        );
+      }
+      if (inspectManagedStopContainers(state.composeProject).length !== 0) {
+        throw new Error("Managed stop absence proof observed a remaining compose population.");
+      }
+      if (inspectProviderRunnerContainers(resolveManagedStopEndpoint(), devsyId).length !== 0) {
+        throw new Error("Managed stop absence proof observed a remaining runner population.");
+      }
+      const owned = inspectWorkspaceContainers().filter(
+        (container) => sameWorkspacePath(
+          container.labels["com.docker.compose.project.working_dir"] ?? "",
+          import_node_path20.default.join(repoPath, ".devcontainer")
+        )
+      );
+      if (owned.length !== 0) {
+        throw new Error("Managed stop absence proof observed a remaining workspace container.");
+      }
+      if (workspace) {
+        const record5 = readWorkspaceOwnership(repoPath, workspace);
+        if (!record5 || record5.devpodId !== devsyId || !sameWorkspacePath(record5.worktreePath, repoPath) || resolveWorktreeWorkspace(repoPath) !== workspace || resolveGitCommonDir(repoPath) !== workspaceEnv?.gitCommonDir || inspectWorkspaceOwnership(record5, listGitWorktrees(repoPath), void 0).ownerStatus !== "present") {
+          throw new Error("Managed stop workspace ownership changed during absence proof.");
+        }
+      }
+      if (!(0, import_node_util4.isDeepStrictEqual)(readManagedRuntimeState(repoPath, workspace), state)) {
+        throw new Error("Managed stop retained state changed during absence proof.");
+      }
+    };
+    observe();
+    observe();
+  }
+  const initialOwner = registrationStatus();
+  if (initialOwner.status === "conflict") throw new Error(initialOwner.reason);
+  if (initialOwner.status === "absent") {
+    proveAbsentRegistrationStop();
+    return "proven-absent";
+  }
   const context = registration2().context;
   if (!context || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(context) || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(devsyId)) {
     throw new Error("Managed stop requires a valid exact Devsy context and workspace ID.");
@@ -7320,6 +7468,7 @@ function assertReliabilityEvent(value) {
     case "launched":
     case "interrupted":
     case "not-started":
+    case "settle":
       valid = isReliabilityId(value.operationId);
       break;
     case "completion":
@@ -7389,8 +7538,13 @@ function transition(state, outcome, effects = []) {
   assertReliabilityState(state);
   return { state, effects, outcome };
 }
-function unchanged(state, outcome) {
-  return transition(cloneState(state), outcome);
+function unchanged(state, outcome, reason2) {
+  const result = transition(cloneState(state), outcome);
+  if (reason2) result.reason = reason2;
+  return result;
+}
+function blocked(state, reason2) {
+  return unchanged(state, "blocked", reason2);
 }
 function advance(value) {
   return value === Number.MAX_SAFE_INTEGER ? null : value + 1;
@@ -7415,7 +7569,10 @@ function updateRunningPhase(state) {
 }
 function handleRequest(state, event) {
   if (state.executionPolicy === "manual" && event.mode === "start")
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      "start requests are not admitted under manual execution policy; use the ensure/stop commands."
+    );
   const existing = state.requests.find((request) => request.key === event.key);
   if (existing) {
     const consumer = state.consumers.find((candidate) => candidate.id === existing.consumerId);
@@ -7482,7 +7639,8 @@ function handleRequest(state, event) {
 }
 function canExecAfterInterruptedEnsure(state) {
   const latestEnsure = [...state.operationHistory].reverse().find((operation) => operation.kind === "ensure");
-  return state.executionPolicy === "manual" && state.desired === "running" && latestEnsure?.status === "INTERRUPTED" && latestEnsure.drained && state.operation?.drained === true && (state.operation.kind === "ensure" && state.phase === "recovering" || state.operation.kind === "exec" && ["COMPLETED", "NOT_LAUNCHED", "NOT_STARTED"].includes(state.operation.status));
+  const quiescent = state.stopProof.workloadsStopped && state.stopProof.routesRemoved;
+  return state.executionPolicy === "manual" && (state.desired === "running" || quiescent && state.desired === "stopped-by-user") && latestEnsure?.status === "INTERRUPTED" && latestEnsure.drained && state.operation?.drained === true && (state.operation.kind === "ensure" && (state.phase === "recovering" || quiescent) || state.operation.kind === "exec" && ["COMPLETED", "NOT_LAUNCHED", "NOT_STARTED"].includes(state.operation.status));
 }
 function handleOperationRequest(state, event) {
   if (state.executionPolicy !== "manual") return unchanged(state, "blocked");
@@ -7495,25 +7653,39 @@ function handleOperationRequest(state, event) {
   if (state.operationHistory.some((entry) => entry.id === event.operationId))
     return unchanged(state, "conflict");
   if (event.kind === "exec" && canExecAfterInterruptedEnsure(state) && event.recoverInterruptedEnsure !== true)
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      "the latest ensure is INTERRUPTED and drained; exec requires recovering it first (run ensure, or exec with recovery proof)."
+    );
   const fullyStopped = state.stopProof.workloadsStopped && state.stopProof.routesRemoved;
   const reconcileEnsure = event.kind === "ensure" && state.operation?.kind === "ensure" && ["NOT_STARTED", "INTERRUPTED"].includes(state.operation.status);
   if (state.operation && (!state.operation.drained || !["COMPLETED", "NOT_LAUNCHED", "NOT_STARTED"].includes(state.operation.status) && !fullyStopped && !reconcileEnsure && !(event.kind === "exec" && event.recoverInterruptedEnsure === true && canExecAfterInterruptedEnsure(state))))
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      `operation ${state.operation.id} is ${state.operation.status} (drained=${state.operation.drained}) and no stop proof, ensure reconciliation, or exec recovery supersedes it.`
+    );
   if (state.phase === "stopping" || state.desired === "parked-for-capacity")
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      `phase is '${state.phase}' with desired '${state.desired}'; wait for the running stop to finish.`
+    );
   if (event.kind === "exec" && (!event.runtimeRunning || state.desired !== "running" && state.intentRevision !== 0))
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      `exec requires a running workspace (runtimeRunning=${event.runtimeRunning}, desired='${state.desired}').`
+    );
   const rollover = state.operationHistory.length >= RELIABILITY_MAX_ITEMS;
   let retired = -1;
   if (rollover) {
-    if (state.operation && (!state.operation.drained || !["COMPLETED", "NOT_LAUNCHED"].includes(state.operation.status)))
-      return unchanged(state, "blocked");
     const latestEnsureId = [...state.operationHistory].reverse().find((entry) => entry.kind === "ensure")?.id;
     retired = state.operationHistory.findIndex(
-      (entry) => entry.id !== state.operation?.id && entry.id !== latestEnsureId && entry.drained && ["COMPLETED", "NOT_LAUNCHED"].includes(entry.status)
+      (entry) => entry.id !== state.operation?.id && entry.id !== latestEnsureId && entry.drained && ["COMPLETED", "NOT_LAUNCHED", "INTERRUPTED"].includes(entry.status)
     );
-    if (retired === -1) return unchanged(state, "blocked");
+    if (retired === -1)
+      return blocked(
+        state,
+        `journal holds ${state.operationHistory.length} entries and every retirable entry is the current operation or the latest ensure.`
+      );
   }
   if (state.desired !== "running" || rollover) {
     const revision = advance(state.intentRevision);
@@ -7568,7 +7740,10 @@ function handleDispatch(state) {
   if (state.operation?.drained || state.operation?.status !== "NOT_STARTED")
     return unchanged(state, "stale");
   if (state.desired !== "running" || state.executionPolicy === "capacity-managed" && state.admission !== "admitted" || state.consumers.length === 0) {
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      `dispatch requires desired 'running' with a registered consumer (desired='${state.desired}', consumers=${state.consumers.length}).`
+    );
   }
   const corrective = state.phase === "recovering" && state.incident !== null;
   state.operation = { ...state.operation, status: "DISPATCH_PENDING", exitCode: null };
@@ -7583,7 +7758,10 @@ function handleDispatchPersisted(state, event) {
   if (state.desired !== "running" || state.executionPolicy === "capacity-managed" && (state.admission !== "admitted" || !state.chargeHeld)) {
     state.operation = setUnknown(state.operation);
     state.chargeHeld = state.executionPolicy === "capacity-managed";
-    return transition(state, "blocked");
+    return blocked(
+      state,
+      `dispatch persistence requires desired 'running' (desired='${state.desired}'); the operation outcome is unknown.`
+    );
   }
   if (state.phase === "recovering" && state.incident !== null && state.incident.correctiveActionsTaken >= state.incident.actionLimit) {
     return unchanged(state, "blocked");
@@ -7631,6 +7809,22 @@ function handleInterrupted(state, event) {
   if (state.desired === "running") state.phase = "recovering";
   return transition(state, "accepted");
 }
+function handleSettle(state, event) {
+  if (state.executionPolicy !== "manual") return unchanged(state, "stale");
+  if (!state.operation || state.operation.id !== event.operationId)
+    return unchanged(state, "stale");
+  if (state.operation.drained && state.operation.status === "INTERRUPTED")
+    return unchanged(state, "joined");
+  if (state.operation.status === "COMPLETED") return unchanged(state, "joined");
+  state.operation = {
+    ...state.operation,
+    status: "INTERRUPTED",
+    drained: true,
+    exitCode: null
+  };
+  if (state.desired === "running") state.phase = "recovering";
+  return transition(state, "accepted");
+}
 function handleObservation(state, event, nowMs) {
   if (state.desired !== "running") return unchanged(state, "stale");
   const previous = state.observations.find(
@@ -7640,7 +7834,10 @@ function handleObservation(state, event, nowMs) {
     return unchanged(state, "stale");
   }
   if (!previous && state.observations.length >= RELIABILITY_MAX_ITEMS)
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      `observation set holds ${state.observations.length} distinct capabilities; observations repeat per capability and never retire.`
+    );
   state.observations = state.observations.filter(
     (observation) => observation.capability !== event.observation.capability
   );
@@ -7668,7 +7865,10 @@ function handleStop(state) {
 function handleStopProof(state, event) {
   if (state.desired === "running") return unchanged(state, "stale");
   if (state.executionPolicy === "manual" && state.operation && !state.operation.drained && event.workloadsStopped && event.routesRemoved)
-    return unchanged(state, "blocked");
+    return blocked(
+      state,
+      `stop proof cannot settle while operation ${state.operation.id} is not drained; wait for its worker or settle the journal.`
+    );
   const previous = { ...state.stopProof };
   if (previous.workloadsStopped === event.workloadsStopped && previous.routesRemoved === event.routesRemoved)
     return unchanged(state, "joined");
@@ -7847,6 +8047,8 @@ function applyReliabilityEvent(state, event, nowMs) {
       return handleCompletion(next, event);
     case "interrupted":
       return handleInterrupted(next, event);
+    case "settle":
+      return handleSettle(next, event);
     case "observation":
       return handleObservation(next, event, nowMs);
     case "stop-proof":
@@ -7882,6 +8084,19 @@ function stepReliability(state, event, nowMs) {
 var import_node_crypto11 = require("crypto");
 var import_node_fs20 = __toESM(require("fs"));
 var import_node_path25 = __toESM(require("path"));
+function installedCliVersion() {
+  return true ? "0.0.67" : "0.0.0-dev";
+}
+function compareCliVersions(left, right) {
+  const parts = (value) => value.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const leftParts = parts(left);
+  const rightParts = parts(right);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
 var MAX_RECORD_BYTES = 1048576;
 function identityKey(identity2) {
   if (!import_node_path25.default.isAbsolute(identity2.repoPath) || import_node_path25.default.resolve(identity2.repoPath) !== identity2.repoPath || identity2.repoPath.includes("\0") || identity2.workspace !== null && !isReliabilityId(identity2.workspace) || !["devpod", "devsy"].includes(identity2.provider)) {
@@ -7898,7 +8113,21 @@ function keys(value, expected) {
   }
 }
 function validate(record5, identity2) {
-  keys(record5, ["version", "identity", "revision", "state", "worker", "effectSequence", "outcome"]);
+  keys(record5, [
+    "version",
+    "identity",
+    "revision",
+    "state",
+    "worker",
+    "effectSequence",
+    "outcome",
+    "writtenByVersion"
+  ]);
+  if (record5.writtenByVersion !== void 0 && compareCliVersions(record5.writtenByVersion, installedCliVersion()) > 0) {
+    throw new Error(
+      `Reliability record was last written by devrouter ${record5.writtenByVersion}, which is newer than the installed ${installedCliVersion()}; upgrade devrouter (devrouter upgrade) before running lifecycle commands.`
+    );
+  }
   keys(record5.identity, ["repoPath", "workspace", "provider"]);
   if (record5.version !== 1 || record5.identity.repoPath !== identity2.repoPath || record5.identity.workspace !== identity2.workspace || record5.identity.provider !== identity2.provider || !isReliabilityCounter(record5.revision) || !isReliabilityCounter(record5.effectSequence)) {
     throw new Error("Reliability record has invalid version, ownership, or counters.");
@@ -8039,6 +8268,7 @@ function updateReliabilityOperation(identity2, operation) {
     if (result && typeof result.then === "function") {
       throw new Error("Reliability record updates must be synchronous.");
     }
+    record5.writtenByVersion = installedCliVersion();
     validate(record5, identity2);
     record5.revision += 1;
     persist(record5);
@@ -12785,7 +13015,9 @@ async function withLifecycleOperationLock(repoPath, operation) {
 function stepRecord(record5, event) {
   const transition2 = stepReliability(record5.state, event, Date.now());
   if (!["accepted", "joined"].includes(transition2.outcome))
-    throw new Error(`Lifecycle transition is ${transition2.outcome}.`);
+    throw new Error(
+      `Lifecycle transition is ${transition2.outcome}.${transition2.reason ? ` ${transition2.reason}` : ""}`
+    );
   record5.state = transition2.state;
 }
 function reconcileDrained(record5) {