@aopslabs/aops 0.3.26 → 0.3.28

package/agent-assets-release/agent-assets/core/bc42dd7792dbe66040e99a7ef3d80b3bc788c72b369b5a065cf936aef29f53fb/manifest.json

@@ -112,6 +112,6 @@
   },
   "schemaVersion": 1,
   "standard": "aops-community-core-v1",
-  "version": "0.3.26",
-  "versionId": "community-core-0.3.26"
+  "version": "0.3.28",
+  "versionId": "community-core-0.3.28"
 }

package/agent-assets-release/agent-assets/inventory.json

@@ -10,8 +10,8 @@
     "name": "aops",
     "optional": false,
     "packageSha256": "bc42dd7792dbe66040e99a7ef3d80b3bc788c72b369b5a065cf936aef29f53fb",
-    "version": "0.3.26",
-    "versionId": "community-core-0.3.26"
+    "version": "0.3.28",
+    "versionId": "community-core-0.3.28"
   },
   "gateway": {
     "byteLength": 621,
@@ -22,7 +22,7 @@
   "kind": "aops-community-agent-assets-inventory-v1",
   "schemaVersion": 1,
   "source": {
-    "commit": "a27236e8340f10b98d86814e4cb25384ee68ffb4",
+    "commit": "4b74e2bab67b40ecc4ea37a972d2747491f7a8b2",
     "repository": "git+https://github.com/eeemzs/aops-platform",
     "root": "apps/aops-cli/assets/agent-assets"
   }

package/agent-assets-release/agent-assets-release.json

@@ -11,8 +11,8 @@
       "name": "aops",
       "optional": false,
       "packageSha256": "bc42dd7792dbe66040e99a7ef3d80b3bc788c72b369b5a065cf936aef29f53fb",
-      "version": "0.3.26",
-      "versionId": "community-core-0.3.26"
+      "version": "0.3.28",
+      "versionId": "community-core-0.3.28"
     },
     "files": [
       {
@@ -118,7 +118,7 @@
       {
         "byteLength": 3811,
         "ref": "agent-assets/core/bc42dd7792dbe66040e99a7ef3d80b3bc788c72b369b5a065cf936aef29f53fb/manifest.json",
-        "sha256": "8b3d8fb2a3d05c995786293bc12bde3801d22b7f34fca45df3bcaeafd62408b8"
+        "sha256": "a7d0ddab5014eb99f6bae0b3b6ef74a5a8c85139a2c4d219c965f36c8e1bd807"
       },
       {
         "byteLength": 621,
@@ -128,7 +128,7 @@
       {
         "byteLength": 926,
         "ref": "agent-assets/inventory.json",
-        "sha256": "a874074fae7653d3d93b505e048df25ce0b75f99f9bbf4b2c6fc9957583330bb"
+        "sha256": "6eb29fbf8c2399e854083ef13c2428440ce23f5088824877dc905a8520e47c1b"
       },
       {
         "byteLength": 281,
@@ -144,7 +144,7 @@
     },
     "inventory": {
       "ref": "agent-assets/inventory.json",
-      "sha256": "a874074fae7653d3d93b505e048df25ce0b75f99f9bbf4b2c6fc9957583330bb"
+      "sha256": "6eb29fbf8c2399e854083ef13c2428440ce23f5088824877dc905a8520e47c1b"
     },
     "kind": "aops-community-agent-assets-release-v1",
     "projection": {
@@ -153,7 +153,7 @@
     },
     "root": "agent-assets",
     "schemaVersion": 1,
-    "setSha256": "b5f5cf790144a78d213050b871f14bf45b2001ab0f1de9a73e890e20129244ba"
+    "setSha256": "02ea968111c9cdad8fe406cb8d9e57e6f26a58644ac193c04f00a6aa577ec3dc"
   },
   "evidence": {
     "signature": {
@@ -161,10 +161,10 @@
     }
   },
   "kind": "aops-community-agent-assets-bundle-v1",
-  "releaseVersion": "0.3.26",
+  "releaseVersion": "0.3.28",
   "schemaVersion": 1,
   "source": {
-    "commit": "a27236e8340f10b98d86814e4cb25384ee68ffb4",
+    "commit": "4b74e2bab67b40ecc4ea37a972d2747491f7a8b2",
     "repository": "git+https://github.com/eeemzs/aops-platform",
     "root": "apps/aops-cli/assets/agent-assets"
   }

package/agent-assets-release/agent-assets-release.sigstore.json

@@ -4,13 +4,13 @@
     "x509CertificateChain": {
       "certificates": [
         {
-          "rawBytes": "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"
+          "rawBytes": "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"
         }
       ]
     },
     "tlogEntries": [
       {
-        "logIndex": "2549925838",
+        "logIndex": "2553771214",
         "logId": {
           "keyId": "wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="
         },
@@ -18,38 +18,38 @@
           "kind": "hashedrekord",
           "version": "0.0.1"
         },
-        "integratedTime": "1787321134",
+        "integratedTime": "1787347232",
         "inclusionPromise": {
-          "signedEntryTimestamp": "MEQCIDSncONAjgcVXpuzdBVGcqVA2vki7lnCIUdJeBvK6gcsAiBBgtUHbxZrko/DFrr18ROYgG02TkFx8AuDZdZNaR0Omw=="
+          "signedEntryTimestamp": "MEQCIDfcm9LkMQJMVzC1y8Zz+3W4lZCSfSEcqVcokF3cL9OQAiA2t3KDqtR5h61DxjgR/24n+diVWnRr1HroMr7gtnRX1g=="
         },
         "inclusionProof": {
-          "logIndex": "2428021576",
-          "rootHash": "+LKuQB3TIMAnL3LTYuTQXyJ64hc4uZ1KYTO3/vNHXio=",
-          "treeSize": "2428021599",
+          "logIndex": "2431866952",
+          "rootHash": "FzfjDKMb7RwLCOsn5MqV4EI4I6He4TxvmsSWsJabXUo=",
+          "treeSize": "2431866964",
           "hashes": [
-            "h9gh73O4rYSronb6GOz5syeHhUKi3C5GYjUY7oijQng=",
-            "cV06tlyujelmONiBiqnx+QUxSEv+xQXpSHhHwPvqtWg=",
-            "8WbeWbDsJCIOpzsADId06qcap5nc2YYD1Eyjuo/2rsw=",
-            "JRib40hknq8xlLZbPitIzYWg5jfEO9mmmx68ey0KWJw=",
-            "TpksfbpZ0gRiwlmr8/2QJcjJOiuyXNbKDncYYgTskOk=",
-            "9r+Y38/eS4pEwIa6GhE155Ks0XRiaHNe1L9phasA/iI=",
-            "Yzc/266OTwEZ5d/muSDENGaOICvYQt/UC4FrXRz4v/w=",
-            "S4f5vTVavyEszlRDCqwxdBz/h39S+qNwDhc7Gc92IkI=",
-            "Ryn1uPqRCd+R0LxxinHyyFbMs/d0zwL8GfigIwIeDlk=",
-            "AvqFfY3iNK3nlPVO3rNJL+lkBfpB+1t5pKeoZvROrHM=",
-            "1Uwz0cBmxMyigjaFyr60M4Nx+sjh+ZQeEV++chbZdx8=",
-            "ZUPJSNagIo2Cuo9rPgcsX/Fhs+Siniykljq/4IU90q8=",
-            "hqdrhjLzPeYTznZc4m+ZY2VU7KPmRsh8feBDuZIMWYE=",
-            "zf+G623/SGJ6XTKZTBaFTZxRLfWHs31RLboxrrfLlkY=",
+            "TkmstTcLV80Z8cCC14nTYMmgLh+WDktBMOMgkpTc0BM=",
+            "ee0gHJOEFErA2/e5JNqBpVFZmpI9p/162qHYajKcUJ4=",
+            "LtPS7ZHwKewZie+9kcDo3GEi+K/OyYmhduazzRJBpwk=",
+            "yDZ7T4a4ZoMY72uid/bnC3pm3ukVkmrYVR15KKrmiks=",
+            "M07J7P95IA48Te8doVTxWxwMs9wCzLp1n4CivkC90ls=",
+            "Ifr+B23ijUQ8mSxGm2huQ33ngNbAkh45/6YVvJ6YkC8=",
+            "PDl2+2g31pAzh7inLT1wKZBgs8IQEH6UbNBtW6NlY/g=",
+            "Oy8zIaaZ4Jjs8LgOH36qYR5qfnXId5Ya/7xJobY3FRQ=",
+            "nb2F2HW8++pxo5kubryZYX4S4GpLlrAHfvhIygp7i48=",
+            "TajTE5zxXucFXS1a0NWZQSd8UUQtAjDtaQ47uEBlsAw=",
+            "LVkP/pXcdaXlrM7GmttJ9G/8UlAsG9peo4xRdefiIdE=",
+            "6pok3vcu/J36uan+mjVjYgeDF8aod94o/h6fjqQvlMA=",
+            "V26C/ZbgRB037k4IypmNXaS2AKEAq+mYdBpCYzUHZaI=",
+            "9573PZDNoVVnalVG+4BpJVrKEFneAwqHLpVdOEfbE0Y=",
             "RhRQJE8gq9XjV+FJY/OHh6ZhCnS6INvqNxL9MyobX54=",
             "SndbMKVtcTenAkwi2JBfGzD+mhexp1qJbRIY+A1JRIU=",
             "xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="
           ],
           "checkpoint": {
-            "envelope": "rekor.sigstore.dev - 1193050959916656506\n2428021599\n+LKuQB3TIMAnL3LTYuTQXyJ64hc4uZ1KYTO3/vNHXio=\n\n— rekor.sigstore.dev wNI9ajBEAiA5tW+Maxzv0l/vjwqGBhYd6Bynuvy/mHoJWVKsU92U8QIgHo5kEBjVtzV9qt+WaQ67/YsYIkcFV2QonBVQCNfLOcA=\n"
+            "envelope": "rekor.sigstore.dev - 1193050959916656506\n2431866964\nFzfjDKMb7RwLCOsn5MqV4EI4I6He4TxvmsSWsJabXUo=\n\n— rekor.sigstore.dev wNI9ajBGAiEA3FKcKQyuF1Qinx8qvAOOpwvjarVMsXB66iDktb8uABkCIQDf7gkJs+AkOBETCt8Asn/QLbwZ65ZXdNgZsi95zCIMsQ==\n"
           }
         },
-        "canonicalizedBody": "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"
+        "canonicalizedBody": "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"
       }
     ],
     "timestampVerificationData": {}
@@ -57,8 +57,8 @@
   "messageSignature": {
     "messageDigest": {
       "algorithm": "SHA2_256",
-      "digest": "BqcbKoAcqpPlrDCVAuuirsjplnWSiI06X9Z/8a4spVI="
+      "digest": "QhzKoPCTdAf3cTGMfy79K0FHq8koJuCMFvSvztwHS7c="
     },
-    "signature": "MEQCIGt1dChCW8P8E4E2m3Y8ML2uShqllRc+FB2cxb6Bl6/MAiB8rVX/4RLtc7OGBMBUDpXkhriGv90iq7GP9JUmnX98Ng=="
+    "signature": "MEYCIQCNSzE2xhjxDtrUYAIcuDf5GbhBDZHIOJk5eGqKS6qUiwIhAKTwEZ28QS6RfAv62BV1++eLNCD1sSK6jjO9eXZnWeGA"
   }
 }

package/dist/commands/community-server.js

@@ -1,3 +1,4 @@
+import { spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, rmSync, } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -17,6 +18,8 @@ import { inspectCommunityDoctor } from './community-doctor.js';
 import { buildCommunityInstanceContract, } from '../lib/community-instance-contract.js';
 import { asCommunityDiagnosticError } from '../lib/community-diagnostic.js';
 import { assertCommunityNativePathLayout, attestCommunityNativeExternalSnapshot, inspectCommunityNativeInstall, inspectCommunityNativeRuntime, loadExternalPostgresUrl, loadExternalServerAuthConfig, planCommunityNativeInstalledMigration, readCommunityNativeLogs, rollbackCommunityNativeApplication, resolveCommunityNativeInstalledNpmSourceRoot, resolveCommunityNativeLaunchMode, resolveCommunityNativePaths, setupCommunityNativeInstall, startCommunityNativeInstall, stopCommunityNativeInstall, } from '../lib/community-native-lifecycle.js';
+import { inspectPgToolchain, locatePgTool, pgEnvironmentFromUrl } from '../lib/pg-tool-location.js';
+import { readAopsServerEnvConfig } from '../utils/community-host-runtime.js';
 import { inspectCommunityNativeApplicationRecoveryStatus } from '../lib/community-native-application-recovery.js';
 import { inspectCommunityNativeDatabaseRecoveryStatus, restoreCommunityNativeDatabaseForUpdate, } from '../lib/community-native-database-recovery.js';
 import { inspectCommunityNativePostgres, removeCommunityNativePostgresContainerForReset, removeCommunityNativeManagedPostgres, } from '../lib/community-native-postgres.js';
@@ -265,6 +268,78 @@ function journalPathsForMode(options, runtimeMode) {
 function inspectFrom(options) {
     return inspectCommunityInstall(installSelection(options));
 }
+const BACKUP_READINESS_CONTRACT = 'aops.backup-readiness/v1';
+function computeCommunityBackupReadiness(options) {
+    const envelope = (body) => ({
+        schemaVersion: 1,
+        contract: BACKUP_READINESS_CONTRACT,
+        ...body,
+    });
+    const native = inspectNativeFrom(options);
+    const state = native.status === 'installed' ? native.state : undefined;
+    if (!state) {
+        const dialect = readAopsServerEnvConfig().repoDialect;
+        if (dialect === 'sqlite')
+            return envelope({ provider: 'no-host-backup', ready: true });
+        return envelope({
+            provider: 'unknown',
+            ready: false,
+            cause: `community_backup_readiness_state_unavailable:${native.status}`,
+        });
+    }
+    const postgres = state.postgres;
+    if (postgres.mode === 'container')
+        return envelope({ provider: 'managed-container', ready: true });
+    if (postgres.mode !== 'external' || !postgres.configRef || !postgres.tlsPolicy) {
+        return envelope({
+            provider: 'unknown',
+            ready: false,
+            cause: 'community_backup_readiness_postgres_state_incomplete',
+        });
+    }
+    let serverMajor;
+    try {
+        const url = loadExternalPostgresUrl(postgres.configRef, postgres.tlsPolicy);
+        const psql = locatePgTool('psql');
+        if (!psql) {
+            return envelope({ provider: 'unknown', ready: false, cause: 'community_backup_readiness_psql_missing' });
+        }
+        const probe = spawnSync(psql, ['--tuples-only', '--no-align', '--command', 'SHOW server_version_num'], {
+            encoding: 'utf8',
+            env: { ...process.env, ...pgEnvironmentFromUrl(String(url)) },
+        });
+        if (probe.error || probe.status !== 0) {
+            return envelope({ provider: 'unknown', ready: false, cause: 'community_backup_readiness_server_unreachable' });
+        }
+        const reported = Number(`${probe.stdout ?? ''}`.trim());
+        if (!Number.isFinite(reported) || reported <= 0) {
+            return envelope({ provider: 'unknown', ready: false, cause: 'community_backup_readiness_server_version_unreadable' });
+        }
+        serverMajor = Math.floor(reported / 10_000);
+    }
+    catch {
+        return envelope({ provider: 'unknown', ready: false, cause: 'community_backup_readiness_postgres_config_unusable' });
+    }
+    const readiness = inspectPgToolchain({
+        serverMajor,
+        run: (command, args) => {
+            const result = spawnSync(command, args, { encoding: 'utf8' });
+            if (result.error || result.status !== 0)
+                throw new Error('community_backup_readiness_tool_failed');
+            return `${result.stdout ?? ''}`;
+        },
+    });
+    return envelope({
+        provider: 'host-tools',
+        ready: readiness.ready,
+        serverMajor: readiness.requiredMajor,
+        tools: readiness.tools.map((evidence) => ({ tool: evidence.tool, major: evidence.major ?? null })),
+        ...(readiness.cause ? { cause: readiness.cause } : {}),
+    });
+}
+function runCommunityServerBackupReadiness(options) {
+    writeResult(computeCommunityBackupReadiness(options), true, options);
+}
 function inspectNativeFrom(options) {
     return inspectCommunityNativeInstall(installSelection(options));
 }
@@ -2195,6 +2270,9 @@ export function makeCommunityServerCommand(identity = {}) {
         .action((options) => runCommunityServerRestart(options, dependencies));
     common(command.command('status').description('Show install and runtime status')).action(runCommunityServerStatus);
     common(command.command('health').description('Check the installed server health without mutation')).action(runCommunityServerHealth);
+    common(command.command('backup-readiness')
+        .description('Report whether this host can take the backup an update depends on, without mutation'))
+        .action(runCommunityServerBackupReadiness);
     common(command.command('migration-plan').description('Read the exact pending native database migration plan without mutation'))
         .action((options) => runCommunityServerMigrationPlan(options, dependencies));
     common(command.command('attest-external-snapshot').description('Optionally record an operator-owned external PostgreSQL snapshot for one risky migration plan'))

package/dist/commands/community-setup.js

@@ -128,6 +128,7 @@ function addSetupInitOptions(command) {
     return command
         .option('--path <path>', 'Setup path: 1 | 2 | 3 | 4 (semantic ids are also accepted)')
         .option('--postgres-config <path>', 'PostgreSQL env file override for path 1, or private output path for path 3')
+        .option('--postgres-bin-dir <path>', 'Directory holding PostgreSQL client tools you installed yourself; setup will not look for or install any')
         .option('--postgres-tls <policy>', 'PostgreSQL TLS policy: disable | require | verify-full')
         .option('--local-postgres-host <host>', 'Path 3 local PostgreSQL loopback host (default: 127.0.0.1)')
         .option('--local-postgres-port <port>', 'Path 3 local PostgreSQL port (default: 5432)', (value) => Number.parseInt(String(value), 10))

package/dist/commands/global-update.js

@@ -358,12 +358,118 @@ function defaultUpdateRoot(configRoot) {
         mkdirSync(root, { recursive: true, mode: 0o700 });
     return plainDirectory(root, 'AOPS config root');
 }
-export function prepareGlobalUpdate(options = {}, run = defaultRunner) {
+function assertKnownDependencies(provided, known, label) {
+    for (const key of Object.keys(provided)) {
+        assert.ok(known.includes(key), `${label} received an unknown dependency: ${key}`);
+    }
+}
+const BACKUP_READINESS_CONTRACT = 'aops.backup-readiness/v1';
+function resolveBackupProvider(run, entrypoint) {
+    let document;
+    try {
+        document = parseJson(run(process.execPath, [entrypoint, 'server', 'backup-readiness', '--json']), 'backup_readiness');
+    }
+    catch {
+        return { kind: 'unknown', reason: 'readiness_command_failed' };
+    }
+    if (document.contract !== BACKUP_READINESS_CONTRACT || document.schemaVersion !== 1) {
+        return { kind: 'unknown', reason: 'readiness_contract_unrecognised' };
+    }
+    const knownAnywhere = ['schemaVersion', 'contract', 'provider', 'ready', 'serverMajor', 'tools', 'cause'];
+    for (const key of Object.keys(document)) {
+        if (!knownAnywhere.includes(key))
+            return { kind: 'unknown', reason: 'readiness_document_unexpected_field' };
+    }
+    const exactKeys = (allowed) => {
+        const keys = Object.keys(document).sort();
+        return keys.length === allowed.length && allowed.slice().sort().every((key, index) => keys[index] === key);
+    };
+    const base = ['schemaVersion', 'contract', 'provider', 'ready'];
+    if (document.provider === 'managed-container' || document.provider === 'no-host-backup') {
+        if (!exactKeys(base) || document.ready !== true) {
+            return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+        }
+        return { kind: document.provider === 'managed-container' ? 'managed-container' : 'no-host-backup' };
+    }
+    if (document.provider === 'unknown') {
+        if (!exactKeys([...base, 'cause']) || document.ready !== false || typeof document.cause !== 'string' ||
+            document.cause.length === 0) {
+            return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+        }
+        return { kind: 'unknown', reason: `readiness_${document.cause}` };
+    }
+    if (document.provider !== 'host-tools') {
+        return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+    }
+    const serverMajor = document.serverMajor;
+    if (!Number.isSafeInteger(serverMajor) || Number(serverMajor) <= 0) {
+        return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+    }
+    const tools = document.tools;
+    if (!Array.isArray(tools) || tools.length !== 2) {
+        return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+    }
+    const evidence = tools.map((entry) => entry);
+    const named = evidence.map((entry) => String(entry.tool)).sort();
+    if (named[0] !== 'pg_dump' || named[1] !== 'pg_restore') {
+        return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+    }
+    for (const entry of evidence) {
+        if (Object.keys(entry).sort().join(',') !== 'major,tool') {
+            return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+        }
+    }
+    const detail = `required_major_${String(serverMajor)} ` +
+        evidence.map((entry) => `${String(entry.tool)}=${entry.major === null ? 'missing' : String(entry.major)}`).join(' ');
+    if (document.ready === true) {
+        if (!exactKeys([...base, 'serverMajor', 'tools'])) {
+            return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+        }
+        for (const entry of evidence) {
+            if (!Number.isSafeInteger(entry.major) || Number(entry.major) < Number(serverMajor)) {
+                return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+            }
+        }
+        return { kind: 'host-tools', ready: true, detail };
+    }
+    if (document.ready !== false || !exactKeys([...base, 'serverMajor', 'tools', 'cause']) ||
+        typeof document.cause !== 'string' || document.cause.length === 0) {
+        return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+    }
+    for (const entry of evidence) {
+        if (entry.major !== null && !Number.isSafeInteger(entry.major)) {
+            return { kind: 'unknown', reason: 'readiness_document_variant_invalid' };
+        }
+    }
+    return { kind: 'host-tools', ready: false, cause: document.cause, detail };
+}
+function assertBackupToolchainReady(resolveProvider) {
+    const provider = resolveProvider();
+    if (provider.kind === 'managed-container' || provider.kind === 'no-host-backup')
+        return false;
+    if (provider.kind === 'unknown') {
+        throw new Error(`community_pg_toolchain_server_major_unknown:${provider.reason}; the server host must let this ` +
+            'command report whether it can back up its own database before an update that dumps it can begin');
+    }
+    if (!provider.ready) {
+        throw new Error(`${provider.cause ?? 'community_pg_toolchain_not_ready'}; the server host must provide PostgreSQL ` +
+            `client tools able to serve its own database before this server can be updated (${provider.detail})`);
+    }
+    return true;
+}
+function serverApplicationUpdateRequired(priorServer, targetServer) {
+    return priorServer !== targetServer;
+}
+export function prepareGlobalUpdate(options = {}, run = defaultRunner, dependencies = {}) {
+    assertKnownDependencies(dependencies, ['resolveBackupProvider'], 'prepareGlobalUpdate');
     const check = inspectGlobalUpdate(run);
     assert.equal(check.updateAvailable, true, 'aops_global_update_not_available');
     const installed = inspectGlobalInstall(run);
     const services = serviceSnapshot(run, installed.cliPath);
     assertHealthyServices(services);
+    if (serverApplicationUpdateRequired(installed.packages.server, check.available.server)) {
+        assertBackupToolchainReady(dependencies.resolveBackupProvider ?? (() => resolveBackupProvider(run, installed.cliPath)));
+    }
     const configRoot = defaultUpdateRoot(options.configRoot);
     const updatesRoot = path.join(configRoot, 'global-updates');
     mkdirSync(updatesRoot, { recursive: true, mode: 0o700 });
@@ -1108,6 +1214,7 @@ export async function recoverGlobalUpdate(options, run = defaultRunner, executio
     }
 }
 export async function applyGlobalUpdate(options, run = defaultRunner, execution = defaultExecutionDependencies) {
+    assertKnownDependencies(execution, ['fetch', 'sleep', 'now', 'resolveBackupProvider'], 'applyGlobalUpdate');
     const plan = readGlobalUpdatePlan(options.plan);
     assert.equal(options.confirm, plan.planId, 'global update confirmation does not match the exact plan');
     assert.equal(existsSync(path.join(plan.operationRoot, RESULT_FILE)), false, 'global_update_plan_already_terminal');
@@ -1117,6 +1224,12 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
     assert.equal(current.globalPrefix, plan.globalPrefix, 'global npm prefix changed after update planning');
     assertHealthyServices(serviceSnapshot(run, current.cliPath));
     const events = new GlobalUpdateEventLog(execution.now ?? (() => new Date()));
+    if (serverApplicationUpdateRequired(plan.prior.packages.server, plan.target.packages.server)) {
+        const candidateEntrypoint = path.join(plan.operationRoot, 'executor', 'node_modules', '@aopslabs', 'aops', 'dist', 'main.js');
+        if (assertBackupToolchainReady(execution.resolveBackupProvider ?? (() => resolveBackupProvider(run, candidateEntrypoint)))) {
+            events.push('verified:backup-toolchain');
+        }
+    }
     let applicationUpdateId = null;
     let applicationUpdateAttempted = false;
     let failedStage = 'stop-cockpit';
@@ -1133,7 +1246,7 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
         const updated = inspectGlobalInstall(run);
         assert.deepEqual(updated.packages, plan.target.packages, 'installed candidate closure is not exact');
         assert.deepEqual(updated.topology, plan.target.topology, 'installed candidate topology is not canonical');
-        if (plan.prior.packages.server === plan.target.packages.server) {
+        if (!serverApplicationUpdateRequired(plan.prior.packages.server, plan.target.packages.server)) {
             failedStage = 'start-unchanged-server';
             startService(run, updated.cliPath, 'server');
             events.push('started:server-unchanged');

package/dist/lib/agent-assets/native-fs.js

@@ -543,9 +543,9 @@ function defaultNativeRoot() {
     return moduleDirectory.endsWith(`${path.sep}dist`) ? bundled : compiledOrSource;
 }
 function injectedNativeManifestSha256() {
-    return typeof "d079a8a4ff6a05567912c963ac82f52259e980fafc22a041e4934932cdf7c2dd" === 'undefined'
+    return typeof "50600a98d6f7643b0dd62d7f6fb9c9761a8d384210dda72b10d4bbb761d3e14a" === 'undefined'
         ? undefined
-        : "d079a8a4ff6a05567912c963ac82f52259e980fafc22a041e4934932cdf7c2dd";
+        : "50600a98d6f7643b0dd62d7f6fb9c9761a8d384210dda72b10d4bbb761d3e14a";
 }
 function sha256(bytes) {
     return createHash('sha256').update(bytes).digest('hex');

package/dist/lib/community-native-backup.js

@@ -3,6 +3,8 @@ import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readF
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { assertBackupUnchanged, hashHeldFile, openBackupForVerify } from './community-migration-snapshot.js';
+import { pgEnvironmentFromUrl, resolvePgTool } from './pg-tool-location.js';
+export { pgEnvironmentFromUrl, resolvePgTool };
 export async function runNativePgProcess(params) {
     return await new Promise((resolve, reject) => {
         const child = spawn(params.tool, params.args, {
@@ -18,54 +20,6 @@ export async function runNativePgProcess(params) {
         child.on('close', (exitCode, signal) => resolve({ exitCode, signal }));
     });
 }
-export function pgEnvironmentFromUrl(repoUrl) {
-    let parsed;
-    try {
-        parsed = new URL(repoUrl);
-    }
-    catch {
-        throw new Error('community_native_backup_repo_url_invalid');
-    }
-    if (parsed.protocol !== 'postgres:' && parsed.protocol !== 'postgresql:') {
-        throw new Error('community_native_backup_repo_url_invalid');
-    }
-    const database = decodeURIComponent(parsed.pathname.replace(/^\//, ''));
-    if (!database)
-        throw new Error('community_native_backup_repo_url_invalid');
-    const env = {
-        PGHOST: parsed.hostname,
-        PGDATABASE: database,
-    };
-    if (parsed.port)
-        env.PGPORT = parsed.port;
-    if (parsed.username)
-        env.PGUSER = decodeURIComponent(parsed.username);
-    if (parsed.password)
-        env.PGPASSWORD = decodeURIComponent(parsed.password);
-    const sslmode = parsed.searchParams.get('sslmode');
-    if (sslmode)
-        env.PGSSLMODE = sslmode;
-    return env;
-}
-export function resolvePgTool(tool, options = {}) {
-    const exists = options.exists ?? existsSync;
-    const executable = process.platform === 'win32' ? `${tool}.exe` : tool;
-    if (options.explicit)
-        return options.explicit;
-    if (options.binDir)
-        return path.join(options.binDir, executable);
-    const candidates = process.platform === 'darwin'
-        ? ['/Applications/pgAdmin 4.app/Contents/SharedSupport', '/opt/homebrew/bin', '/usr/local/bin']
-        : process.platform === 'win32'
-            ? ['C:\\Program Files\\PostgreSQL\\17\\bin', 'C:\\Program Files\\PostgreSQL\\16\\bin']
-            : ['/usr/bin', '/usr/local/bin'];
-    for (const dir of candidates) {
-        const candidate = path.join(dir, executable);
-        if (exists(candidate))
-            return candidate;
-    }
-    return executable;
-}
 function assertSafeBackupRoot(backupRoot) {
     mkdirSync(backupRoot, { recursive: true, mode: 0o700 });
     const stats = lstatSync(backupRoot, { bigint: true });

package/dist/lib/pg-client-acquisition.js

@@ -0,0 +1,90 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+export function distributionCodename(readOsRelease = () => readFileSync('/etc/os-release', 'utf8')) {
+    let content;
+    try {
+        content = readOsRelease();
+    }
+    catch {
+        return undefined;
+    }
+    const match = /^VERSION_CODENAME=("?)([a-z][a-z0-9]*)\1\s*$/mu.exec(content);
+    return match?.[2];
+}
+export function planPgClientAcquisition(major, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const hasCommand = options.hasCommand ?? (() => true);
+    if (!Number.isInteger(major) || major <= 0)
+        return undefined;
+    if (platform === 'darwin') {
+        if (!hasCommand('brew'))
+            return undefined;
+        const args = ['install', `postgresql@${major}`];
+        return {
+            platform,
+            major,
+            steps: [{ command: 'brew', args }],
+            display: `brew ${args.join(' ')}`,
+            needsPrivilege: false,
+        };
+    }
+    if (platform === 'win32') {
+        if (!hasCommand('winget'))
+            return undefined;
+        const args = ['install', '--exact', '--silent', `PostgreSQL.PostgreSQL.${major}`];
+        return {
+            platform,
+            major,
+            steps: [{ command: 'winget', args }],
+            display: `winget ${args.join(' ')}`,
+            needsPrivilege: false,
+        };
+    }
+    if (!hasCommand('apt-get'))
+        return undefined;
+    const keyPath = '/usr/share/postgresql-common/pgdg/apt.postgresql.org.asc';
+    const codename = options.codename ?? distributionCodename();
+    if (!codename)
+        return undefined;
+    const listLine = `deb [signed-by=${keyPath}] https://apt.postgresql.org/pub/repos/apt ${codename}-pgdg main`;
+    return {
+        platform,
+        major,
+        steps: [
+            { command: 'apt-get', args: ['update'] },
+            { command: 'apt-get', args: ['install', '-y', 'curl', 'ca-certificates', 'gnupg'] },
+            { command: 'install', args: ['-d', '/usr/share/postgresql-common/pgdg'] },
+            { command: 'curl', args: ['-fsSL', '-o', keyPath, 'https://www.postgresql.org/media/keys/ACCC4CF8.asc'] },
+            { command: 'sh', args: ['-c', `echo '${listLine}' > /etc/apt/sources.list.d/pgdg.list`] },
+            { command: 'apt-get', args: ['update'] },
+            { command: 'apt-get', args: ['install', '-y', `postgresql-client-${major}`] },
+        ],
+        display: `sudo apt-get install -y postgresql-client-${major} (after adding apt.postgresql.org)`,
+        needsPrivilege: true,
+    };
+}
+export function acquirePgClient(options) {
+    const plan = planPgClientAcquisition(options.major, {
+        platform: options.platform,
+        hasCommand: options.hasCommand,
+        ...(options.codename ? { codename: options.codename } : {}),
+    });
+    if (!plan)
+        return { status: 'unavailable', major: options.major };
+    const privileged = options.isPrivileged ?? (() => typeof process.getuid === 'function' && process.getuid() === 0);
+    if (plan.needsPrivilege && !privileged()) {
+        return { status: 'failed', plan, reason: 'pg_client_acquisition_requires_privilege' };
+    }
+    try {
+        for (const step of plan.steps)
+            options.run(step.command, step.args);
+    }
+    catch (error) {
+        return { status: 'failed', plan, reason: error instanceof Error ? error.message : 'pg_client_acquisition_failed' };
+    }
+    return { status: 'acquired', plan };
+}
+export function explicitPgBinDir(input) {
+    const value = String(input ?? '').trim();
+    return value.length > 0 ? path.resolve(value) : undefined;
+}

package/dist/lib/pg-tool-location.js

@@ -0,0 +1,148 @@
+import { existsSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+function windowsClientDirectories(listDirectory) {
+    const root = 'C:\\Program Files\\PostgreSQL';
+    const list = listDirectory ?? ((directory) => {
+        try {
+            return readdirSync(directory);
+        }
+        catch {
+            return [];
+        }
+    });
+    return list(root)
+        .map((entry) => ({ entry, major: Number(entry) }))
+        .filter((candidate) => Number.isInteger(candidate.major) && candidate.major > 0)
+        .sort((left, right) => right.major - left.major)
+        .map((candidate) => `${root}\\${candidate.entry}\\bin`);
+}
+export function pgToolCandidates(tool, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const executable = platform === 'win32' ? `${tool}.exe` : tool;
+    const directories = platform === 'darwin'
+        ? ['/Applications/pgAdmin 4.app/Contents/SharedSupport', '/opt/homebrew/bin', '/usr/local/bin']
+        : platform === 'win32'
+            ? windowsClientDirectories(options.listDirectory)
+            : ['/usr/bin', '/usr/local/bin'];
+    return [executable, ...directories.map((directory) => path.join(directory, executable))];
+}
+export function resolvePgTool(tool, options = {}) {
+    const exists = options.exists ?? existsSync;
+    const platform = options.platform ?? process.platform;
+    const executable = platform === 'win32' ? `${tool}.exe` : tool;
+    if (options.explicit)
+        return options.explicit;
+    if (options.binDir)
+        return path.join(options.binDir, executable);
+    const candidates = platform === 'darwin'
+        ? ['/Applications/pgAdmin 4.app/Contents/SharedSupport', '/opt/homebrew/bin', '/usr/local/bin']
+        : platform === 'win32'
+            ? windowsClientDirectories(options.listDirectory)
+            : ['/usr/bin', '/usr/local/bin'];
+    for (const dir of candidates) {
+        const candidate = path.join(dir, executable);
+        if (exists(candidate))
+            return candidate;
+    }
+    return executable;
+}
+export function locatePgDump(env = process.env, exists = existsSync) {
+    return locatePgTool('pg_dump', env, exists);
+}
+export function locatePgTool(tool, env = process.env, exists = existsSync) {
+    const resolved = resolvePgTool(tool, { exists });
+    if (resolved.includes(path.sep))
+        return resolved;
+    const searchPath = (env.PATH ?? '').split(path.delimiter).filter((entry) => entry.length > 0);
+    for (const entry of searchPath) {
+        const candidate = path.join(entry, resolved);
+        if (exists(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export function pgEnvironmentFromUrl(repoUrl) {
+    let parsed;
+    try {
+        parsed = new URL(repoUrl);
+    }
+    catch {
+        throw new Error('community_native_backup_repo_url_invalid');
+    }
+    if (parsed.protocol !== 'postgres:' && parsed.protocol !== 'postgresql:') {
+        throw new Error('community_native_backup_repo_url_invalid');
+    }
+    const database = decodeURIComponent(parsed.pathname.replace(/^\//, ''));
+    if (!database)
+        throw new Error('community_native_backup_repo_url_invalid');
+    const env = {
+        PGHOST: parsed.hostname,
+        PGDATABASE: database,
+    };
+    if (parsed.port)
+        env.PGPORT = parsed.port;
+    if (parsed.username)
+        env.PGUSER = decodeURIComponent(parsed.username);
+    if (parsed.password)
+        env.PGPASSWORD = decodeURIComponent(parsed.password);
+    const sslmode = parsed.searchParams.get('sslmode');
+    if (sslmode)
+        env.PGSSLMODE = sslmode;
+    return env;
+}
+export function parsePgToolMajor(reported) {
+    const line = reported.trim();
+    const marked = /\(PostgreSQL\)\s+(\d+)/i.exec(line);
+    const fallback = /(?:^|\s)(\d+)\.\d+/.exec(line);
+    const major = Number((marked ?? fallback)?.[1] ?? Number.NaN);
+    return Number.isInteger(major) && major > 0 ? major : undefined;
+}
+export function inspectPgToolchain(options) {
+    const requiredMajor = options.serverMajor;
+    const tools = [];
+    let cause;
+    for (const tool of ['pg_dump', 'pg_restore']) {
+        let located;
+        let major;
+        for (const candidate of pgToolCandidates(tool, { platform: options.platform })) {
+            let reported;
+            try {
+                reported = options.run(candidate, ['--version']);
+            }
+            catch {
+                continue;
+            }
+            const parsed = parsePgToolMajor(reported);
+            located = candidate;
+            if (parsed !== undefined) {
+                major = parsed;
+                break;
+            }
+        }
+        if (located === undefined) {
+            tools.push({ tool });
+            cause ??= `community_pg_toolchain_missing:${tool}:required_major_${requiredMajor}`;
+            continue;
+        }
+        tools.push({ tool, path: located, major });
+        if (major === undefined) {
+            cause ??= `community_pg_toolchain_unusable:${tool}:required_major_${requiredMajor}`;
+            continue;
+        }
+        if (major < requiredMajor) {
+            cause ??= `community_pg_toolchain_major_too_old:${tool}:found_${major}:required_${requiredMajor}`;
+        }
+    }
+    return { requiredMajor, tools, ready: cause === undefined, cause };
+}
+export function assertPgToolchainReady(options) {
+    const readiness = inspectPgToolchain(options);
+    if (readiness.ready)
+        return readiness;
+    const detail = readiness.tools
+        .map((evidence) => `${evidence.tool}=${evidence.major ?? (evidence.path ? 'unusable' : 'missing')}`)
+        .join(' ');
+    throw new Error(`${readiness.cause}; the server host must provide PostgreSQL client tools of major ` +
+        `${readiness.requiredMajor} or newer -- the major this host's own database reports -- ` +
+        `before this server can be updated (${detail})`);
+}

package/dist/lib/setup-init-orchestrator.js

@@ -1,3 +1,6 @@
+import { acquirePgClient, explicitPgBinDir } from './pg-client-acquisition.js';
+import { inspectPgToolchain } from './pg-tool-location.js';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { logInfo, logSuccess, logWarn } from '@aopslabs/xf-cli-ui';
 import { canonicalCommercialJson, managedInstallationLayoutBinding, sha256Commercial, } from '@aopslabs/artifact-trust-contracts';
@@ -197,6 +200,51 @@ function resolveOfficialCatalogReleasePath(value) {
     }
     return path.resolve(normalized);
 }
+async function ensureBackupToolchain(connection, options) {
+    const serverMajor = Number(connection.serverMajor);
+    if (!Number.isInteger(serverMajor) || serverMajor <= 0) {
+        return { action: 'setup.backup-toolchain', status: 'skipped', reason: 'server_major_unknown' };
+    }
+    const binDir = explicitPgBinDir(options.postgresBinDir);
+    const probe = (command, args) => {
+        const result = spawnSync(command, args, { encoding: 'utf8' });
+        if (result.error || result.status !== 0)
+            throw new Error('pg_client_probe_failed');
+        return `${result.stdout ?? ''}`;
+    };
+    const before = inspectPgToolchain({ serverMajor, run: probe, ...(binDir ? { binDir } : {}) });
+    if (before.ready) {
+        return { action: 'setup.backup-toolchain', status: 'ready', serverMajor, source: binDir ? 'operator' : 'host' };
+    }
+    const outcome = acquirePgClient({
+        major: serverMajor,
+        run: (command, args) => {
+            const result = spawnSync(command, [...args], { encoding: 'utf8' });
+            if (result.error)
+                throw result.error;
+            if (result.status !== 0)
+                throw new Error(`${command} exited with ${result.status ?? 'unknown'}`);
+        },
+    });
+    if (outcome.status !== 'acquired') {
+        return {
+            action: 'setup.backup-toolchain',
+            status: 'action-required',
+            serverMajor,
+            cause: before.cause,
+            ...(outcome.status === 'failed' ? { install: outcome.plan.display, reason: outcome.reason } : {}),
+            next: 'Install PostgreSQL client tools of this major, or pass --postgres-bin-dir if they are already installed.',
+        };
+    }
+    const after = inspectPgToolchain({ serverMajor, run: probe, ...(binDir ? { binDir } : {}) });
+    return {
+        action: 'setup.backup-toolchain',
+        status: after.ready ? 'installed' : 'action-required',
+        serverMajor,
+        installed: outcome.plan.display,
+        ...(after.ready ? {} : { cause: after.cause }),
+    };
+}
 export async function runSetupInitOrchestrator(options = {}, dependencies = {}) {
     const inspectReadiness = dependencies.inspectReadiness ?? inspectSetupReadiness;
     const setupCommunityServer = dependencies.setupCommunityServer ?? runCommunityServerSetup;
@@ -408,6 +456,7 @@ export async function runSetupInitOrchestrator(options = {}, dependencies = {})
             throw error;
         }
         steps.push({ action: 'setup.postgres-connection', ...connection });
+        steps.push(await ensureBackupToolchain(connection, options));
     }
     if (selectedPath === 'native-local') {
         const localCheck = initial.checks.find((check) => check.id === 'local-postgresql');

package/native/manifest.json

@@ -42,7 +42,7 @@
       "capabilityClass": "windows-ntfs-crash-recoverable-v1",
       "qualification": {
         "relativePath": "qualifications/win32-x64.json",
-        "sha256": "25c8d0971355c6d4f73817dd1b1a91d40579313a43a1624c35427f3445af942a"
+        "sha256": "8cc3d15f86ed5b243b4d2ba834f239e57db89c0a9987e5d7ca30ab13cc6b2706"
       }
     }
   ]

package/native/qualifications/win32-x64.json

@@ -7,7 +7,7 @@
   "filesystem": "NTFS",
   "primitiveProfile": "windows-createfile-flush-movefileex-v1",
   "capabilityClass": "windows-ntfs-crash-recoverable-v1",
-  "evidenceSha256": "2090a30f52f1d5f2e4c2fd1dfcc0095966e998224ce023cc9fbeb456dc92617a",
+  "evidenceSha256": "8d22f4416cad09beaa5f8b81b01b3da95cf9f2dca5d270f6f25ce7b67b8dd778",
   "crashInjectionPoints": [
     "authority-history",
     "authority-current",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aopslabs/aops",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "type": "module",
   "description": "AOPS CLI and terminal setup application.",
   "aopsDockerServerVersion": "0.2.17",
@@ -23,7 +23,7 @@
     "test:setup-docker": "node --test test/setup-docker-server.test.mjs",
     "test:native-lifecycle": "node --test test/community-native-lifecycle.test.mjs",
     "test:migration-snapshot-gate": "node --test test/community-migration-snapshot-gate.test.mjs",
-    "test:backup-gate-parity": "node --test test/community-backup-gate-parity.test.mjs test/community-backup-list.test.mjs test/community-native-backup.test.mjs",
+    "test:backup-gate-parity": "node --test test/community-backup-gate-parity.test.mjs test/community-backup-list.test.mjs test/community-native-backup.test.mjs test/pg-client-acquisition.test.mjs",
     "test:migration-auto-dump": "node --test test/community-migration-auto-dump.test.mjs",
     "test:memory-search-window": "node --test test/memory-search-window-shape.test.mjs",
     "test:db-restore-source-root": "node --test test/db-restore-source-root.test.mjs",
@@ -70,15 +70,16 @@
     "test:chat-wake-watch": "node --test test/chat-wake-watch.test.mjs",
     "test:codex-wake": "node --test test/codex-wake.test.mjs",
     "test:commercial-lifecycle-evidence": "node --test test/commercial-lifecycle-evidence.test.mjs test/commercial-lifecycle-evidence-projection.test.mjs",
-    "test:commercial-effects": "node --test test/commercial-interruption-removal-effects.test.mjs test/commercial-natural-controls-effects.test.mjs test/commercial-transition-effects.test.mjs"
+    "test:commercial-effects": "node --test test/commercial-interruption-removal-effects.test.mjs test/commercial-natural-controls-effects.test.mjs test/commercial-transition-effects.test.mjs",
+    "test:pg-client-acquisition": "node --test test/pg-client-acquisition.test.mjs"
   },
   "dependencies": {
     "@aopslabs/aops-agent-runtime": "0.1.0",
-    "@aopslabs/aops-server": "0.2.20",
+    "@aopslabs/aops-server": "0.2.22",
     "@aopslabs/artifact-trust-contracts": "0.3.1",
     "@aopslabs/cli-kit": "0.1.0",
     "@aopslabs/aops-host-registration": "0.2.2",
-    "@aopslabs/aops-pg-bootstrap": "0.2.5",
+    "@aopslabs/aops-pg-bootstrap": "0.2.7",
     "@aopslabs/aops-runtime-config": "0.2.2",
     "@sigstore/bundle": "4.0.0",
     "@sigstore/protobuf-specs": "0.5.1",