@zq-silk/yui 0.15.12 → 0.16.1

package/dist/cli/parseRepeatable.js

@@ -0,0 +1,35 @@
+import { usageError } from "../errors/cliError.js";
+export function parseRepeatable(args, repeatable, singular, usage, flags = new Set()) {
+    const positionals = [];
+    const many = new Map();
+    const one = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (flags.has(value)) {
+            if (one.has(value))
+                throw usageError(`Option may only be specified once: ${value}.`, usage);
+            one.set(value, "true");
+            continue;
+        }
+        if (!repeatable.has(value) && !singular.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (singular.has(value) && one.has(value)) {
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        }
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        if (repeatable.has(value))
+            many.set(value, [...(many.get(value) ?? []), optionValue]);
+        else
+            one.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, many, one };
+}

package/dist/cli/updatePorts.js

@@ -238,6 +238,7 @@ export function createUpdatePorts(environment, spawn = spawnSync, stagingRoot =
 }
 const UPDATE_CLI_PATH = fileURLToPath(new URL("../cli.js", import.meta.url));
 const UPDATE_CLIENT_RUNTIME_PATH = fileURLToPath(new URL("../controller/clientRuntime.js", import.meta.url));
+const UPDATE_INVENTORY_PATH = fileURLToPath(new URL("../controller/resourceInventoryLinux.js", import.meta.url));
 const UPDATE_CONTROLLER_RECONCILIATION_PATH = fileURLToPath(new URL("../controller/updateReconciliation.js", import.meta.url));
 /**
  * Capture running state plus an authenticated exact process identity before
@@ -354,6 +355,7 @@ function stopReplacementControllerForUpdate(home, expectedPid, environment, spaw
 function runSchemaIndependentControllerStop(home, environment, spawn, expectedPid) {
     const helper = [
         "const values = process.argv.slice(1);",
+        "const handoverOwnerPid = Number(values.pop());",
         "const expectedPid = values.length === 3 ? Number(values.pop()) : undefined;",
         "const home = values.pop();",
         "const runtimeModule = values.pop();",
@@ -361,6 +363,7 @@ function runSchemaIndependentControllerStop(home, environment, spawn, expectedPi
         "  const { stopFileTaskController } = await import(runtimeModule);",
         "  const data = await stopFileTaskController(home, {",
         "    environment: process.env,",
+        "    handoverOwnerPid,",
         "    ...(expectedPid === undefined ? {} : { expectedPid })",
         "  });",
         "  process.stdout.write(JSON.stringify({ ok: true, data }));",
@@ -376,7 +379,10 @@ function runSchemaIndependentControllerStop(home, environment, spawn, expectedPi
         helper,
         UPDATE_CLIENT_RUNTIME_PATH,
         home,
-        ...(expectedPid === undefined ? [] : [String(expectedPid)])
+        ...(expectedPid === undefined ? [] : [String(expectedPid)]),
+        // The runtime validates the existing lock owner; the child must identify
+        // its owning updater instead of waiting on the parent's lock as foreign.
+        String(process.pid)
     ], { cwd: process.cwd(), env: { ...environment, YUI_HOME: home }, shell: false });
     if (result.error !== undefined || result.status !== 0) {
         const detail = result.stderr.toString("utf8").trim();
@@ -490,10 +496,11 @@ function restoreControllerIdentity(home, identity, environment, spawn) {
     // Spawn a detached child through a short-lived Node helper so the synchronous
     // update process can still use the authenticated, bounded readiness handshake
     // shared by Controller startup. No retry, sleep, or new identity inference is
-    // hidden here.
+    // hidden here. Restoration participates in the same parent-owned lock.
     const helper = [
         "const { spawn } = require('node:child_process');",
         "const values = process.argv.slice(1);",
+        "const handoverOwnerPid = Number(values.pop());",
         "const version = values.pop();",
         "const args = JSON.parse(values.pop());",
         "const executable = values.pop();",
@@ -503,6 +510,7 @@ function restoreControllerIdentity(home, identity, environment, spawn) {
         "  const { ensureFileTaskControllerIdentity } = await import(runtimeModule);",
         "  await ensureFileTaskControllerIdentity(home, { executablePath: executable, args, version }, {",
         "    environment: process.env,",
+        "    handoverOwnerPid,",
         "    spawnController: (_home, launchEnv) => {",
         "      const child = spawn(executable, args, { detached: true, stdio: 'ignore', env: launchEnv });",
         "      child.unref();",
@@ -517,23 +525,44 @@ function restoreControllerIdentity(home, identity, environment, spawn) {
         home,
         identity.executablePath,
         JSON.stringify(identity.args),
-        identity.version
+        identity.version,
+        String(process.pid)
     ], { cwd: process.cwd(), env: launchEnvironment, shell: false, stdio: "pipe" });
     assertSpawnOk(result, "restore the previously running Controller identity");
 }
 function runControllerCommand(home, environment, spawn, method, cliBinary) {
-    const command = cliBinary ?? process.execPath;
-    const args = cliBinary === undefined
+    let command = cliBinary ?? process.execPath;
+    let args = cliBinary === undefined
         ? [UPDATE_CLI_PATH, "--json", "controller", method]
         : ["--json", "controller", method];
+    if (method === "status") {
+        // Lifecycle capture consumes the resource collector, not public status's
+        // current-schema health verdict. This is the same schema-independent seam
+        // used for update-owned stop/reconciliation, with no environment bypass.
+        const inventoryModule = cliBinary === undefined
+            ? UPDATE_INVENTORY_PATH
+            : join(dirname(activatedControllerEntrypoint(cliBinary)), "resourceInventoryLinux.js");
+        const helper = [
+            "(async () => {",
+            "  const { pathToFileURL } = await import('node:url');",
+            "  const { scanControllerResourceInventory } = await import(pathToFileURL(process.argv[1]).href);",
+            "  const data = await scanControllerResourceInventory({",
+            "    currentHome: process.argv[2], scope: 'current', environment: process.env",
+            "  });",
+            "  process.stdout.write(JSON.stringify({ ok: true, data }));",
+            "})().catch(error => {",
+            "  process.stderr.write(JSON.stringify({ ok: false, code: error.code ?? 'RUNTIME_ERROR', message: error.message }));",
+            "  process.exitCode = 5;",
+            "});"
+        ].join(" ");
+        command = process.execPath;
+        args = ["-e", helper, inventoryModule, home];
+    }
     const result = spawn(command, args, {
         cwd: process.cwd(),
         env: {
             ...environment,
             YUI_HOME: home,
-            // Lifecycle capture needs the schema-independent resource inventory,
-            // not the optional current-schema identity health verdict.
-            YUI_STATUS_IDENTITY: "0",
             // This exact lifecycle child is part of the update process that owns
             // the handover lock. Managed Sessions never receive this bypass.
             YUI_UPDATE_HANDOVER_OWNER_PID: String(process.pid)