@deksden-com/dd-flow-cli 0.9.0-beta.13 → 0.9.0-beta.133

package/dist/services/managed-daemon-binding.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { managedProcessRuntimeHome, managedProcessStatus } from "./managed-processes.js";
+export function readNativeDaemonState(stateDir) {
+    if (!path.isAbsolute(stateDir))
+        throw new AppError("daemon_owner_mismatch", "Native state directory must be absolute", 1);
+    return JSON.parse(fs.readFileSync(path.join(stateDir, "daemon.json"), "utf8"));
+}
+/** A shared directory or logical owner is not a physical provider binding. */
+export function managedProviderBelongsToDaemon(provider, daemon, state) {
+    const child = JSON.parse(provider.metadata_json), parent = JSON.parse(daemon.metadata_json);
+    return provider.kind === daemon.kind.replace(/-daemon$/, "-provider")
+        && state.provider_process?.id === provider.id && state.provider_process.lease_token === provider.lease_token
+        && Boolean(provider.pid && provider.pid_started_at && daemon.pid && daemon.pid_started_at)
+        && state.provider_pid === provider.pid && child.owner_pid === daemon.pid && child.owner_pid_started_at === daemon.pid_started_at
+        && provider.owner_id === daemon.owner_id && provider.project_id === daemon.project_id && provider.run_id === daemon.run_id && provider.work_id === daemon.work_id
+        && child.state_dir === parent.state_dir && child.role === parent.role && child.dd_flow_home === parent.dd_flow_home && child.adapter_executable === parent.adapter_executable
+        && child.dispatch_barrier === "run-generation@1" && child.budget?.scope_id === parent.budget?.scope_id;
+}
+/** Identity proof only. Liveness and clean shutdown are separate caller decisions. */
+export function requireManagedDaemonBinding(context, input) {
+    const state = readNativeDaemonState(input.stateDir);
+    const owner = state.config?.runtime_owner;
+    const record = managedProcessStatus(context).find(record => record.id === state.resource_process?.id);
+    const metadata = record && JSON.parse(record.metadata_json);
+    if (!record || !owner || !record.kind.endsWith("-daemon")
+        || record.lease_token !== state.resource_process?.lease_token
+        || !record.pid || record.pid !== state.pid || !record.pid_started_at
+        || record.owner_id !== owner.owner_id || input.ownerId !== undefined && record.owner_id !== input.ownerId
+        || record.project_id !== input.projectId || owner.project_id !== input.projectId
+        || record.run_id !== input.runId || owner.run_id !== input.runId
+        || metadata?.state_dir !== input.stateDir || owner.state_dir !== input.stateDir
+        || owner.dd_flow_home !== context.ddFlowHome || managedProcessRuntimeHome(record, context) !== context.ddFlowHome) {
+        throw new AppError("daemon_owner_mismatch", "Native daemon has no proven physical ownership in this RUN and runtime home", 1);
+    }
+    return { state, process: record };
+}

package/dist/services/managed-lease-monitor.js

@@ -0,0 +1,133 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { AppError } from "../shared/errors.js";
+import { createRenewalState, maintenanceRetryable, renewalConfirmed, renewalDelay, renewalFailure, renewalRemaining, RENEWAL_POLICY } from "../harness-runtime/lib/lease-renewal.mjs";
+/** Registry renewals happen outside RUN writers. Assertions never renew. */
+export function managedLeaseMonitor(renew, leaseExpiresAt = null) {
+    const episode = createRenewalState({ leaseExpiresAt });
+    let expiry = 0;
+    let failure = null;
+    let lost = false;
+    let fatal = null;
+    let closing = false;
+    let pending;
+    const shutdown = new AbortController();
+    const retainAuthority = (leaseExpiresAt) => {
+        if (!renewalConfirmed(episode, performance.now(), leaseExpiresAt))
+            throw new AppError("managed_lease_receipt_invalid", "Confirmation has no current persisted expiry", 1);
+        expiry = Date.parse(leaseExpiresAt);
+    };
+    const uncertain = () => new AppError("controller_lease_unconfirmed", "Managed lease requires confirmation outside the writer", 1, { cause: failure, exhausted: episode.exhausted, closing });
+    const assertNoRenewal = () => {
+        if (closing)
+            throw uncertain();
+        if (fatal)
+            throw fatal;
+        if (lost)
+            throw new AppError("controller_lease_lost", "Managed owner was replaced or retired", 1);
+        if (failure || Date.now() >= expiry)
+            throw uncertain();
+    };
+    const tick = () => {
+        if (closing)
+            throw uncertain();
+        if (fatal)
+            throw fatal;
+        if (lost || failure && !renewalRemaining(episode) || episode.exhausted)
+            return;
+        try {
+            episode.uncertainSince ??= performance.now();
+            const remaining = renewalRemaining(episode);
+            if (!remaining) {
+                failure = uncertain();
+                return;
+            }
+            const receipt = renew(Math.min(RENEWAL_POLICY.attemptMs, remaining));
+            if (!receipt.owned) {
+                lost = true;
+                return;
+            }
+            const value = Date.parse(receipt.lease_expires_at);
+            if (!Number.isFinite(value))
+                throw new AppError("managed_lease_receipt_invalid", "Renewal has no valid persisted expiry", 1);
+            if (value <= Date.now())
+                throw new AppError("controller_lease_unconfirmed", "Renewal receipt has already expired", 1);
+            if (renewalConfirmed(episode, performance.now(), receipt.lease_expires_at)) {
+                expiry = value;
+                failure = null;
+            }
+            else
+                failure = uncertain();
+        }
+        catch (error) {
+            failure = error;
+            if (maintenanceRetryable(error) || error instanceof AppError && error.code === "controller_lease_unconfirmed")
+                renewalFailure(episode);
+            else {
+                fatal = error;
+                throw error;
+            }
+        }
+    };
+    const assertConfirmed = () => { tick(); assertNoRenewal(); };
+    const runConfirmation = async (assertCurrent) => {
+        for (;;) {
+            if (closing)
+                throw uncertain();
+            assertCurrent();
+            tick();
+            try {
+                assertNoRenewal();
+                return;
+            }
+            catch (error) {
+                if (lost || episode.exhausted || !renewalRemaining(episode))
+                    throw error;
+                try {
+                    await delay(Math.min(renewalDelay(episode), renewalRemaining(episode)), undefined, { signal: shutdown.signal });
+                }
+                catch (cause) {
+                    if (closing)
+                        throw uncertain();
+                    throw cause;
+                }
+            }
+        }
+    };
+    const ensureConfirmed = async (assertCurrent = () => { }) => {
+        if (closing)
+            throw uncertain();
+        if (pending)
+            assertCurrent();
+        pending ??= runConfirmation(assertCurrent).finally(() => { pending = undefined; });
+        await pending;
+        if (closing)
+            throw uncertain();
+        assertCurrent();
+        assertNoRenewal();
+    };
+    const background = (assertCurrent, onFailure, onConfirmed = () => { }) => {
+        void ensureConfirmed(assertCurrent).then(() => {
+            if (closing)
+                return;
+            try {
+                onConfirmed();
+            }
+            catch (error) {
+                fatal = failure = error;
+                throw error;
+            }
+        }).catch(error => {
+            if (closing)
+                return;
+            try {
+                onFailure(error);
+            }
+            catch (reporting) {
+                fatal = failure = reporting;
+            }
+        });
+    };
+    return { tick, assertNoRenewal, assertConfirmed, ensureConfirmed, background, retainAuthority,
+        close: () => { closing = true; shutdown.abort(); },
+        isConfirmed: () => !closing && !lost && !failure && Date.now() < expiry };
+}