@runuai/host 0.9.14 → 0.9.43

package/lib/managed-activation-watcher.ts

@@ -0,0 +1,72 @@
+export const MANAGED_ACTIVATION_POLL_MS = 5_000;
+
+export interface ManagedActivationWatcherOptions {
+  readonly restartRequired: () => boolean | Promise<boolean>;
+  readonly isIdle: () => boolean;
+  readonly onReady: () => void;
+  readonly onError?: (error: unknown) => void;
+  readonly pollMs?: number;
+  readonly setTimer?: (callback: () => void, delayMs: number) => NodeJS.Timeout;
+  readonly clearTimer?: (timer: NodeJS.Timeout) => void;
+}
+
+/**
+ * Watches the durable activation marker left by another CLI process. New work
+ * is rejected while that marker exists; this loop waits for the selected
+ * runtime to be current and all existing work to finish before asking the
+ * service supervisor to exec the stable launcher.
+ */
+export class ManagedActivationWatcher {
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+  private stopped = false;
+  private readonly pollMs: number;
+  private readonly setTimer: NonNullable<ManagedActivationWatcherOptions["setTimer"]>;
+  private readonly clearTimer: NonNullable<ManagedActivationWatcherOptions["clearTimer"]>;
+
+  constructor(private readonly options: ManagedActivationWatcherOptions) {
+    this.pollMs = options.pollMs ?? MANAGED_ACTIVATION_POLL_MS;
+    if (!Number.isSafeInteger(this.pollMs) || this.pollMs <= 0) {
+      throw new Error("managed activation poll interval is invalid");
+    }
+    this.setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+    this.clearTimer = options.clearTimer ?? clearTimeout;
+  }
+
+  start(): void {
+    if (this.stopped || this.timer || this.running) return;
+    this.schedule();
+  }
+
+  stop(): void {
+    this.stopped = true;
+    if (this.timer) this.clearTimer(this.timer);
+    this.timer = null;
+  }
+
+  private schedule(): void {
+    if (this.stopped) return;
+    this.timer = this.setTimer(() => {
+      this.timer = null;
+      void this.run();
+    }, this.pollMs);
+    this.timer.unref?.();
+  }
+
+  private async run(): Promise<void> {
+    if (this.stopped || this.running) return;
+    this.running = true;
+    try {
+      if ((await this.options.restartRequired()) && this.options.isIdle()) {
+        this.stop();
+        this.options.onReady();
+        return;
+      }
+    } catch (error) {
+      this.options.onError?.(error);
+    } finally {
+      this.running = false;
+    }
+    this.schedule();
+  }
+}

package/lib/managed-install-owner-watcher.ts

@@ -0,0 +1,55 @@
+import type { ManagedRuntimeInstallStartupState } from "./managed-runtime";
+
+export interface ManagedInstallOwnerWatcherOptions {
+  readonly check: () => Promise<ManagedRuntimeInstallStartupState>;
+  readonly onRestart: (state: "stale" | "attested") => void;
+  readonly onUnsafe: (error: unknown) => void;
+  readonly intervalMs?: number;
+}
+
+/**
+ * Watches only a daemon that started provisionally under an install intent.
+ * `unknown` is a transient process-identity result and must never authorize a
+ * rollback or restart. `none` means completion removed the admission fence and
+ * permanently disarms this watcher for the ordinary steady-state daemon.
+ */
+export class ManagedInstallOwnerWatcher {
+  private timer: NodeJS.Timeout | null = null;
+  private checking = false;
+
+  constructor(private readonly options: ManagedInstallOwnerWatcherOptions) {}
+
+  start(): void {
+    if (this.timer) return;
+    this.timer = setInterval(
+      () => void this.tick(),
+      this.options.intervalMs ?? 1_000,
+    );
+    this.timer.unref?.();
+  }
+
+  stop(): void {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  private async tick(): Promise<void> {
+    if (this.checking || !this.timer) return;
+    this.checking = true;
+    try {
+      const state = await this.options.check();
+      if (state === "none") {
+        this.stop();
+      } else if (state === "stale" || state === "attested") {
+        this.stop();
+        this.options.onRestart(state);
+      }
+    } catch (error) {
+      this.stop();
+      this.options.onUnsafe(error);
+    } finally {
+      this.checking = false;
+    }
+  }
+}

package/lib/managed-operation-drain.ts

@@ -0,0 +1,49 @@
+/**
+ * Counts asynchronous host mutations that must settle before a managed-runtime
+ * restart may terminate the process. The factory form increments first, so no
+ * synchronous setup performed by the operation can escape the drain.
+ */
+export class ManagedOperationDrain {
+  private active = 0;
+  private accepting = true;
+
+  constructor(private readonly onSettled: () => void) {}
+
+  get activeCount(): number {
+    return this.active;
+  }
+
+  /**
+   * Refuse factories that arrive after managed shutdown has begun. Existing
+   * operations remain counted until their full promise chains (including the
+   * bridge acknowledgement) settle.
+   */
+  stopAccepting(): void {
+    this.accepting = false;
+  }
+
+  track<T>(operation: () => Promise<T>): Promise<T> {
+    if (!this.accepting) {
+      return Promise.reject(
+        new Error("managed host is shutting down; retry the operation"),
+      );
+    }
+    this.active += 1;
+    let result: Promise<T>;
+    try {
+      result = operation();
+    } catch (error) {
+      this.settle();
+      return Promise.reject(error);
+    }
+    return Promise.resolve(result).finally(() => this.settle());
+  }
+
+  private settle(): void {
+    this.active -= 1;
+    if (this.active < 0) {
+      throw new Error("managed operation drain settled more work than it tracked");
+    }
+    this.onSettled();
+  }
+}