@forgezero/agent 0.1.20 → 0.1.21

package/README.md

@@ -144,6 +144,12 @@ read Vault data, accept arbitrary commands, or retain tenant credentials. Root
 SSH is an operator-only platform-genesis/recovery path, not the normal tenant
 dispatch mechanism.
 
+Shutdown has one process-wide deadline. New deployment claims and background
+sync stop first, claimed work drains under its lease fence, and only then do the
+queues and application socket close. Vault/attestation calls or a stale local
+socket cannot consume systemd's longer stop timeout: exceeding the Agent deadline
+is reported and exits non-zero instead of being silently killed midway by PID 1.
+
 Repository read authorization is explicit per pipeline: public HTTPS, the
 compute's systemd-sealed SSH deploy key, or a fine-grained HTTPS token selected
 by a project-vault secret name. A signed claim contains the mode and secret name

package/dist/fz-agent.js

@@ -2714,8 +2714,31 @@ async function applyMetalIsolation(profile, exec = defaultExec) {
   }
 }
 
+// src/shutdown.ts
+async function settleWithin(work, timeoutMs, setTimer = setTimeout, clearTimer = clearTimeout) {
+  let timer;
+  try {
+    return await Promise.race([
+      work.then(() => true),
+      new Promise((resolve2) => {
+        timer = setTimer(() => resolve2(false), Math.max(1, timeoutMs));
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimer(timer);
+  }
+}
+async function closeServerWithin(server, timeoutMs) {
+  const closed = await settleWithin(new Promise((resolve2) => server.close(() => resolve2())), timeoutMs);
+  if (!closed)
+    server.unref();
+  return closed;
+}
+
 // src/version.ts
-var VERSION = "0.1.20";
+var VERSION = "0.1.21";
 
 // src/index.ts
 function loadOrCreateSeed(path) {
@@ -3150,24 +3173,26 @@ if (import.meta.main) {
         return;
       stopping = true;
       console.log(`[agent] ${signal}: stopping deployment intake and draining`);
-      if (control)
-        await new Promise((resolve2) => control.close(() => resolve2()));
       const deadlineMs = Math.max(1, Number(process.env.FZ_DRAIN_DEADLINE_MS ?? 30000));
       const deadline = Date.now() + deadlineMs;
+      const remaining = () => Math.max(1, deadline - Date.now());
+      const controlClosed = control ? await settleWithin(new Promise((resolve2) => control.close(() => resolve2())), remaining()) : true;
       const pullDrain = pull?.stop() ?? Promise.resolve();
       const vaultDrain = vaultSync?.stop() ?? Promise.resolve();
       const attestationDrain = attestationLoop?.stop() ?? Promise.resolve();
-      const pullWithinDeadline = pull ? Promise.race([
-        pullDrain.then(() => true),
-        new Promise((resolve2) => setTimeout(() => resolve2(false), deadlineMs))
-      ]) : Promise.resolve(true);
-      const pullDrained = await pullWithinDeadline;
-      await Promise.all([vaultDrain, attestationDrain]);
-      const managerReports = await Promise.all([...new Set(managers.values())].map((manager) => manager.stop(Math.max(1, deadline - Date.now()))));
-      await new Promise((resolve2) => server.close(() => resolve2()));
+      const pullDrained = pull ? await settleWithin(pullDrain, remaining()) : true;
+      const backgroundDrained = await settleWithin(Promise.all([vaultDrain, attestationDrain]), remaining());
+      const managerReports = await Promise.all([...new Set(managers.values())].map((manager) => manager.stop(remaining())));
+      const socketClosed = await closeServerWithin(server, remaining());
       const timedOut = managerReports.some((report) => report.timedOut);
-      console.log(`[agent] drain ${JSON.stringify({ managers: managerReports, pullDrained })}`);
-      process.exit(timedOut || !pullDrained ? 1 : 0);
+      console.log(`[agent] drain ${JSON.stringify({
+        managers: managerReports,
+        controlClosed,
+        pullDrained,
+        backgroundDrained,
+        socketClosed
+      })}`);
+      process.exit(timedOut || !controlClosed || !pullDrained || !backgroundDrained || !socketClosed ? 1 : 0);
     };
     process.on("SIGTERM", () => void shutdown("SIGTERM"));
     process.on("SIGINT", () => void shutdown("SIGINT"));
@@ -3175,19 +3200,24 @@ if (import.meta.main) {
     console.log("[agent] signing/vault mode only; deployment root and pull are not configured");
     if (vaultSync || attestationLoop) {
       let stopping = false;
-      const stop = async () => {
+      const stop = async (signal) => {
         if (stopping)
           return;
         stopping = true;
-        await Promise.all([
+        const deadlineMs = Math.max(1, Number(process.env.FZ_DRAIN_DEADLINE_MS ?? 30000));
+        const deadline = Date.now() + deadlineMs;
+        const remaining = () => Math.max(1, deadline - Date.now());
+        console.log(`[agent] ${signal}: stopping background intake and draining`);
+        const backgroundDrained = await settleWithin(Promise.all([
           vaultSync?.stop() ?? Promise.resolve(),
           attestationLoop?.stop() ?? Promise.resolve()
-        ]);
-        await new Promise((resolve2) => server.close(() => resolve2()));
-        process.exit(0);
+        ]), remaining());
+        const socketClosed = await closeServerWithin(server, remaining());
+        console.log(`[agent] drain ${JSON.stringify({ backgroundDrained, socketClosed })}`);
+        process.exit(backgroundDrained && socketClosed ? 0 : 1);
       };
-      process.on("SIGTERM", () => void stop());
-      process.on("SIGINT", () => void stop());
+      process.on("SIGTERM", () => void stop("SIGTERM"));
+      process.on("SIGINT", () => void stop("SIGINT"));
     }
   }
 }

package/dist/fz.js

@@ -774,7 +774,7 @@ async function resolveIdentity(selector, socketPath) {
 }
 
 // src/version.ts
-var VERSION = "0.1.20";
+var VERSION = "0.1.21";
 
 // src/cli/index.ts
 var DEFAULT_MODE = THRESHOLD_MODES[0].id;

package/dist/shutdown.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from 'node:net';
+/**
+ * Wait for one shutdown stage without allowing it to consume systemd's entire
+ * stop timeout. The work is not cancelled: deployment/lease code retains its
+ * own fencing rules, while the caller decides whether an expired global drain
+ * deadline must terminate the process non-zero.
+ */
+export declare function settleWithin(work: Promise<unknown>, timeoutMs: number, setTimer?: typeof setTimeout, clearTimer?: typeof clearTimeout): Promise<boolean>;
+/** Stop accepting local Vault clients, but never let one stale socket defeat shutdown. */
+export declare function closeServerWithin(server: Server, timeoutMs: number): Promise<boolean>;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** One package version shared by both public binaries. Pinned to package.json by tests. */
-export declare const VERSION = "0.1.20";
+export declare const VERSION = "0.1.21";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"//": "Publishing happens from an operator's machine, not CI \u2014 CLAUDE.md records that the absence of CI is deliberate. npm's `provenance` attests a tarball was built by a recognised CI provider from a named commit, so it cannot be produced here: it was set, and the first publish failed with `Automatic provenance generation not supported for provider: null`. A setting that can never be satisfied is worse than none, because it reads as a guarantee nobody is getting. Restore it the day this publishes from CI, and not before.",
 	"name": "@forgezero/agent",
-	"version": "0.1.20",
+	"version": "0.1.21",
 	"type": "module",
 	"scripts": {
 		"check": "tsc --noEmit",