@zq-silk/yui 0.8.9 → 0.10.0

package/dist/commands/sessionCommands.js

@@ -1,5 +1,121 @@
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
+export function parseSessionStopOptions(args) {
+    if (args.length !== 1 || args[0] !== "--all") {
+        throw usageError("Session stop usage: yui session stop --all.");
+    }
+    return { all: true };
+}
+/**
+ * Stop every current managed Session only when all of them are idle. The
+ * all-or-nothing preflight prevents a maintenance command from silently
+ * stopping half the topology while another Role is still working.
+ */
+export async function runSessionStopCommand(input) {
+    void input.options;
+    if (input.environment?.YUI_SESSION_SCOPE !== undefined) {
+        throw usageError("Session stop must be run by the user from a normal shell, outside a managed Yui Session.");
+    }
+    const maintenance = input.runtime.beginMaintenance();
+    let completed = false;
+    try {
+        const initial = input.runtime.snapshot();
+        const initiallyBlocked = blockedSessions(initial);
+        if (initiallyBlocked.length > 0)
+            return blockedStopResult(initiallyBlocked);
+        // Stop and drain the Controller while the handover fence prevents a new
+        // Leader dispatch. The explicit full pass settles pending runtime inbox and
+        // lifecycle work that may exist without a current Session candidate.
+        await input.runtime.drainController();
+        await input.runtime.stopController();
+        // Re-read the authoritative facts after the drain because a Run that was
+        // already inside a pass may have changed state meanwhile.
+        const settled = input.runtime.snapshot();
+        const blockedAfterDrain = blockedSessions(settled);
+        if (blockedAfterDrain.length > 0) {
+            await input.runtime.startController();
+            return blockedStopResult(blockedAfterDrain);
+        }
+        for (const session of settled.candidates) {
+            const candidate = settled.dormant.find((entry) => sameStopCandidate(session, entry));
+            if (candidate === undefined) {
+                throw new Error(`Dormant Session changed during maintenance: ${renderSessionOwner(session)}.`);
+            }
+            await input.runtime.stopDormantSession(candidate);
+        }
+        const count = settled.candidates.length;
+        completed = true;
+        return {
+            output: count === 0
+                ? "No managed Sessions were running. The Controller remains stopped; run `yui update` now.\n"
+                : `Stopped ${count} managed Sessions. The Controller remains stopped; run \`yui update\` now.\n`,
+            data: { stopped: settled.candidates, blocked: [] },
+            exitCode: 0
+        };
+    }
+    catch (error) {
+        if (!completed) {
+            try {
+                await input.runtime.startController();
+            }
+            catch (restartError) {
+                throw new AggregateError([error, restartError], "Session maintenance failed and the Controller could not be restarted.");
+            }
+        }
+        throw error;
+    }
+    finally {
+        maintenance.release();
+    }
+}
+function blockedSessions(input) {
+    return input.candidates.flatMap((session) => {
+        const idle = input.dormant.some((candidate) => sameStopCandidate(session, candidate));
+        if (idle)
+            return [];
+        return [{
+                session,
+                reason: session.status === "running"
+                    ? "running"
+                    : "runtime-work-pending"
+            }];
+    });
+}
+function blockedStopResult(blocked) {
+    const details = blocked.map(({ session, reason }) => (`- ${renderSessionOwner(session)} (${reason === "running"
+        ? "a Turn or Run is still running"
+        : "an active Run or lifecycle operation is still pending"})`));
+    return {
+        output: [
+            `Cannot stop managed Sessions: ${blocked.length} Session(s) are still busy.`,
+            ...details,
+            "No Session was stopped. Let the listed work finish, then run `yui session stop --all` again."
+        ].join("\n") + "\n",
+        data: { stopped: [], blocked },
+        exitCode: 5
+    };
+}
+function sameStopCandidate(session, candidate) {
+    if (session.owner.scope !== candidate.owner.scope)
+        return false;
+    if (session.owner.roleName !== candidate.owner.roleName)
+        return false;
+    if (session.owner.scope === "task"
+        && candidate.owner.scope === "task"
+        && session.owner.taskId !== candidate.owner.taskId) {
+        return false;
+    }
+    return session.agentId === candidate.agentId
+        && session.adapterId === candidate.adapterId
+        && session.nativeSessionId === candidate.nativeSessionId
+        && session.launchId === candidate.launchId
+        && session.sessionUpdatedAt === candidate.sessionUpdatedAt;
+}
+function renderSessionOwner(session) {
+    return session.owner.scope === "task"
+        ? `${session.owner.taskId}/${session.owner.roleName}`
+        : `global/${session.owner.roleName}`;
+}
 export function parseSessionReconcileOptions(args) {
     const allowed = new Set(["--report", "--cleanup"]);
     if (args.some((argument) => !allowed.has(argument))) {

package/dist/commands/taskBaseCommands.js

@@ -1,5 +1,5 @@
 import { usageError } from "../errors/cliError.js";
-import { assertTaskBaseFreshnessForCompletion, inspectTaskBaseFreshness, renderTaskBaseFreshnessReport } from "../repository/taskBaseFreshness.js";
+import { inspectTaskBaseFreshness, renderTaskBaseFreshnessReport } from "../repository/taskBaseFreshness.js";
 export async function runTaskBaseStatusCommand(args, store, options = {}) {
     const usage = "Task base status usage: yui task base status <task> [--refresh].";
     const refresh = args.includes("--refresh");
@@ -11,19 +11,9 @@ export async function runTaskBaseStatusCommand(args, store, options = {}) {
         git: options.git,
         refresh
     });
-    assertReportIsDeliverySafe(report);
     return {
         kind: "output",
         output: renderTaskBaseFreshnessReport(report),
         data: report
     };
 }
-function assertReportIsDeliverySafe(report) {
-    try {
-        assertTaskBaseFreshnessForCompletion(report);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw usageError(`${renderTaskBaseFreshnessReport(report)}${message}`);
-    }
-}