@aopslabs/aops 0.3.23 → 0.3.25

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 "8829e388a6594a397d3177b17cc67f390cb37902e6d297136cbdc67a6cd44371" === 'undefined'
+    return typeof "be8edaec42b9c18b9590c7fb62b3fe828bd87d2d631314726a2d508861fc2313" === 'undefined'
         ? undefined
-        : "8829e388a6594a397d3177b17cc67f390cb37902e6d297136cbdc67a6cd44371";
+        : "be8edaec42b9c18b9590c7fb62b3fe828bd87d2d631314726a2d508861fc2313";
 }
 function sha256(bytes) {
     return createHash('sha256').update(bytes).digest('hex');

package/dist/lib/community-cockpit-lifecycle.js

@@ -205,6 +205,71 @@ function terminalObservation(record, observedAt, disappeared = false) {
         signal: record.signal ?? null,
     };
 }
+export const COCKPIT_PID_START_TOLERANCE_MS = 300_000;
+export function classifyTerminalCockpitPids(params) {
+    if (params.identityPresent) {
+        return { stale: false, reason: 'community_cockpit_terminal_identity_file_present', findings: [] };
+    }
+    if (params.livePids.length === 0) {
+        return { stale: false, reason: 'community_cockpit_terminal_no_live_pid', findings: [] };
+    }
+    const recordedStart = Date.parse(params.record.startedAt);
+    if (!Number.isFinite(recordedStart)) {
+        return { stale: false, reason: 'community_cockpit_pid_record_start_unparsable', findings: [] };
+    }
+    const tolerance = params.startToleranceMs ?? COCKPIT_PID_START_TOLERANCE_MS;
+    const findings = [];
+    let blocked = null;
+    for (const { pid, role } of params.livePids) {
+        let inspection;
+        try {
+            inspection = params.inspect(pid);
+        }
+        catch (error) {
+            inspection = {
+                outcome: 'undetermined',
+                pid,
+                reason: error instanceof Error ? error.message : 'community_cockpit_pid_inspection_threw',
+            };
+        }
+        if (inspection.outcome === 'absent') {
+            findings.push({ pid, role, outcome: 'absent', disagreedOn: ['identity', 'start-time', 'host-entry'], reason: null });
+            continue;
+        }
+        if (inspection.outcome === 'undetermined') {
+            findings.push({ pid, role, outcome: 'undetermined', disagreedOn: [], reason: inspection.reason });
+            blocked ??= `community_cockpit_pid_inspection_undetermined:${pid}:${inspection.reason}`;
+            continue;
+        }
+        const observedStart = Date.parse(inspection.startedAt);
+        if (!Number.isFinite(observedStart)) {
+            findings.push({ pid, role, outcome: 'inspected', disagreedOn: [], reason: 'start_time_unparsable' });
+            blocked ??= `community_cockpit_pid_start_time_unparsable:${pid}`;
+            continue;
+        }
+        if (inspection.command.trim() === '') {
+            findings.push({ pid, role, outcome: 'inspected', disagreedOn: [], reason: 'command_unavailable' });
+            blocked ??= `community_cockpit_pid_command_unavailable:${pid}`;
+            continue;
+        }
+        const disagreedOn = ['identity'];
+        if (Math.abs(observedStart - recordedStart) > tolerance)
+            disagreedOn.push('start-time');
+        if (!commandNamesHostEntry(inspection.command, params.record.hostEntry))
+            disagreedOn.push('host-entry');
+        findings.push({ pid, role, outcome: 'inspected', disagreedOn, reason: null });
+        if (disagreedOn.length !== 3) {
+            blocked ??= `community_cockpit_pid_may_be_owned:${pid}:${disagreedOn.join('+')}`;
+        }
+    }
+    if (blocked)
+        return { stale: false, reason: blocked, findings };
+    return { stale: true, reason: 'community_cockpit_terminal_record_pid_reused', findings };
+}
+function commandNamesHostEntry(command, hostEntry) {
+    const normalise = (value) => value.split('\\').join('/').toLowerCase();
+    return normalise(command).includes(normalise(hostEntry));
+}
 async function observeCockpit(params) {
     const record = params.processRecord;
     const identityPresent = existsSync(params.paths.identityPath);
@@ -254,11 +319,40 @@ async function observeCockpit(params) {
                 terminalObservation: terminalObservation(record, record.updatedAt),
             };
         }
+        const observation = terminalObservation(record, record.updatedAt);
+        const verdict = observation.classification === 'clean-exit'
+            ? classifyTerminalCockpitPids({
+                record,
+                identityPresent,
+                livePids: [
+                    ...(supervisorAlive ? [{ pid: record.pid, role: 'supervisor' }] : []),
+                    ...(hostAlive && hostPid ? [{ pid: hostPid, role: 'host' }] : []),
+                ],
+                inspect: params.runtime.inspectProcess ?? ((pid) => ({
+                    outcome: 'undetermined',
+                    pid,
+                    reason: 'community_cockpit_pid_inspection_unavailable',
+                })),
+            })
+            : {
+                stale: false,
+                reason: `community_cockpit_terminal_record_with_live_or_unowned_process:${observation.classification}`,
+                findings: [],
+            };
+        if (verdict.stale) {
+            return {
+                ...base,
+                runtimeState: 'stopped', recoverable: true, process: record, identity,
+                supervisorAlive, hostAlive, health: 'not-checked',
+                reason: verdict.reason,
+                terminalObservation: observation,
+            };
+        }
         return {
             ...base,
             runtimeState: 'identity-conflict', recoverable: false, process: record, identity,
             supervisorAlive, hostAlive, health: 'not-checked',
-            reason: 'community_cockpit_terminal_record_with_live_or_unowned_process',
+            reason: verdict.reason,
             terminalObservation: null,
         };
     }

package/dist/lib/community-migration-snapshot.js

@@ -265,6 +265,33 @@ export function readCommunityNativeSnapshotEvidenceV1(params) {
     }
     return { evidencePath, evidenceSha256, evidence };
 }
+export function assertBackupUnchanged(params) {
+    const reread = hashHeldFile(params.heldFd, false);
+    if (reread.sha256 !== params.expectedSha256 || reread.byteLength !== params.expectedByteLength) {
+        throw new Error('community_native_snapshot_backup_identity_changed');
+    }
+}
+export function openBackupForVerify(params) {
+    const noFollow = typeof constants.O_NOFOLLOW === 'number' ? constants.O_NOFOLLOW : 0;
+    const verifyFd = openSync(params.backupPath, constants.O_RDONLY | noFollow);
+    try {
+        const written = fstatSync(params.writtenFd, { bigint: true });
+        const opened = fstatSync(verifyFd, { bigint: true });
+        if (!opened.isFile() || opened.nlink !== 1n ||
+            opened.dev !== written.dev || opened.ino !== written.ino ||
+            opened.size !== BigInt(params.expectedByteLength)) {
+            throw new Error('community_native_snapshot_backup_identity_changed');
+        }
+    }
+    catch (error) {
+        try {
+            closeSync(verifyFd);
+        }
+        catch { }
+        throw error;
+    }
+    return verifyFd;
+}
 async function runDocker(params) {
     const result = await params.runtime.run({
         command: 'docker',
@@ -298,7 +325,7 @@ async function runDockerCapture(params) {
     }
     return result.stdout;
 }
-function hashHeldFile(fd, syncBeforeRead = true) {
+export function hashHeldFile(fd, syncBeforeRead = true) {
     if (syncBeforeRead)
         fsyncSync(fd);
     const before = fstatSync(fd, { bigint: true });
@@ -473,13 +500,18 @@ export async function createCommunityNativeManagedSnapshotV1(params) {
             operation: 'verify_create',
             signal: params.signal,
         });
+        const verifyFd = openBackupForVerify({
+            backupPath,
+            writtenFd: backupFd,
+            expectedByteLength: backup.byteLength,
+        });
         try {
             await runDocker({
                 runtime,
                 args: ['container', 'exec', '-i', state.containerName, 'pg_restore', '-U', 'aops',
                     '-d', verifyDatabase, '--no-owner', '--no-acl', '--exit-on-error'],
                 operation: 'verify_restore',
-                inputFd: backupFd,
+                inputFd: verifyFd,
                 signal: params.signal,
             });
             const restored = await (params.planStrictPgSchema ?? planCommunityStrictPgSchema)({
@@ -490,6 +522,10 @@ export async function createCommunityNativeManagedSnapshotV1(params) {
             assertRestoredState(params.planning, restored);
         }
         finally {
+            try {
+                closeSync(verifyFd);
+            }
+            catch { }
             await runDocker({
                 runtime,
                 args: ['container', 'exec', state.containerName, 'dropdb', '-U', 'aops', '--if-exists', '--force', verifyDatabase],
@@ -497,6 +533,11 @@ export async function createCommunityNativeManagedSnapshotV1(params) {
                 signal: params.signal,
             });
         }
+        assertBackupUnchanged({
+            heldFd: backupFd,
+            expectedSha256: backup.sha256,
+            expectedByteLength: backup.byteLength,
+        });
         const dataFingerprint = sourceDataFingerprint(params.planning);
         const evidence = {
             schemaVersion: 1,

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

@@ -0,0 +1,386 @@
+import { spawn } from 'node:child_process';
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { assertBackupUnchanged, hashHeldFile, openBackupForVerify } from './community-migration-snapshot.js';
+export async function runNativePgProcess(params) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(params.tool, params.args, {
+            env: params.env ? { ...process.env, ...params.env } : process.env,
+            stdio: [
+                params.inputFd === undefined ? 'ignore' : params.inputFd,
+                params.outputFd === undefined ? 'ignore' : params.outputFd,
+                'inherit',
+            ],
+            shell: false,
+        });
+        child.on('error', reject);
+        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 });
+    if (stats.isSymbolicLink() || !stats.isDirectory()) {
+        throw new Error('community_backup_root_unsafe');
+    }
+    return realpathSync.native(backupRoot);
+}
+export function verifyHeldBackupAgainstReceipt(params) {
+    const hashed = hashHeldFile(params.heldFd, false);
+    if (hashed.byteLength !== params.receipt.byteLength) {
+        throw new Error('community_native_backup_size_mismatch');
+    }
+    if (hashed.sha256 !== params.receipt.sha256) {
+        throw new Error('community_native_backup_digest_mismatch');
+    }
+}
+export function planSchemaRewind(params) {
+    const inArchive = new Set([...params.archiveSchemas, 'public']);
+    const orphaned = params.databaseSchemas.filter((name) => !inArchive.has(name));
+    if (orphaned.length > 0) {
+        throw new Error(`community_native_restore_schema_not_in_backup:${orphaned.join(',')}:` +
+            'dropping_would_lose_them_keeping_would_leave_a_partial_rewind');
+    }
+    const drop = new Set(params.databaseSchemas);
+    drop.add('public');
+    return { drop: [...drop].sort() };
+}
+export function quoteSchemaIdentifier(name) {
+    if (name === '' || name.includes('\u0000')) {
+        throw new Error('community_native_restore_schema_name_unrepresentable');
+    }
+    return `"${name.replace(/"/g, '""')}"`;
+}
+export function parseArchiveSchemas(pgRestoreListOutput) {
+    const names = new Set();
+    for (const line of pgRestoreListOutput.split('\n')) {
+        const match = /\bSCHEMA\s+-\s+(\S+)/.exec(line);
+        if (match?.[1])
+            names.add(match[1]);
+    }
+    return [...names].sort();
+}
+export async function resolveSchemaRewindPlan(params) {
+    const pgEnv = pgEnvironmentFromUrl(params.repoUrl);
+    const capture = params.captureOutput ?? defaultCaptureOutput;
+    const query = "select nspname from pg_namespace where nspname not in ('information_schema','pg_catalog','pg_toast') and nspname not like 'pg_temp%' and nspname not like 'pg_toast_temp%'";
+    const databaseSchemas = (await capture({
+        tool: resolvePgTool('psql', { explicit: params.psql, binDir: params.pgBinDir }),
+        args: ['--dbname', String(pgEnv.PGDATABASE), '--tuples-only', '--no-align', '--quiet', '--command', query],
+        env: pgEnv,
+    }))
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const archiveSchemas = parseArchiveSchemas(await capture(params.archiveFd === undefined
+        ? {
+            tool: resolvePgTool('pg_restore', { explicit: params.pgRestore, binDir: params.pgBinDir }),
+            args: ['--list', params.archivePath],
+        }
+        : {
+            tool: resolvePgTool('pg_restore', { explicit: params.pgRestore, binDir: params.pgBinDir }),
+            args: ['--list'],
+            inputFd: params.archiveFd,
+        }));
+    return planSchemaRewind({ databaseSchemas, archiveSchemas });
+}
+async function defaultCaptureOutput(params) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(params.tool, params.args, {
+            stdio: [params.inputFd ?? 'ignore', 'pipe', 'inherit'],
+            shell: false,
+            env: params.env ? { ...process.env, ...params.env } : process.env,
+        });
+        let out = '';
+        const stdout = child.stdout;
+        if (!stdout) {
+            reject(new Error('community_native_restore_schema_probe_no_output'));
+            return;
+        }
+        stdout.setEncoding('utf8');
+        stdout.on('data', (chunk) => { out += chunk; });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code !== 0)
+                reject(new Error(`community_native_restore_schema_probe_failed:exit_${String(code)}`));
+            else
+                resolve(out);
+        });
+    });
+}
+function hashBackupAtPath(backupPath) {
+    const fd = openSync(backupPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        return hashHeldFile(fd, false).sha256;
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch { }
+    }
+}
+export async function verifyCommunityNativeBackupV1(params) {
+    const readText = params.readFileText ?? ((candidate) => readFileSync(candidate, 'utf8'));
+    const receiptPath = `${params.backupPath}.json`;
+    if (!existsSync(receiptPath))
+        throw new Error('community_native_backup_receipt_missing');
+    let record;
+    try {
+        record = JSON.parse(readText(receiptPath));
+    }
+    catch {
+        throw new Error('community_native_backup_receipt_unreadable');
+    }
+    if (record?.kind !== 'native-pg-custom' || record.schemaVersion !== 1 || record.verified !== true) {
+        throw new Error('community_native_backup_receipt_invalid');
+    }
+    if (record.verifiedBy !== undefined && record.verifiedBy !== 'pg-restore-list') {
+        throw new Error('community_native_backup_receipt_unknown_verification_depth');
+    }
+    if (path.resolve(String(record.path)) !== path.resolve(params.backupPath)) {
+        throw new Error('community_native_backup_receipt_path_mismatch');
+    }
+    const stats = params.statFile ? params.statFile(params.backupPath) : statSync(params.backupPath);
+    if (stats.size !== record.byteLength)
+        throw new Error('community_native_backup_size_mismatch');
+    const digest = params.hashFile ? params.hashFile(params.backupPath) : hashBackupAtPath(params.backupPath);
+    if (digest !== record.sha256)
+        throw new Error('community_native_backup_digest_mismatch');
+    return record;
+}
+export async function createCommunityNativeBackupV1(params) {
+    const run = params.runProcess ?? runNativePgProcess;
+    const now = params.now ?? (() => new Date());
+    const backupRoot = assertSafeBackupRoot(params.backupRoot);
+    const label = params.label ? `-${params.label.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 64)}` : '';
+    const backupPath = path.join(backupRoot, `${now().toISOString().replace(/[:.]/g, '-')}${label}-${randomUUID()}.dump`);
+    const noFollow = typeof constants.O_NOFOLLOW === 'number' ? constants.O_NOFOLLOW : 0;
+    const backupFd = openSync(backupPath, constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | noFollow, 0o600);
+    let keep = false;
+    try {
+        const pgEnv = pgEnvironmentFromUrl(params.repoUrl);
+        const dump = await run({
+            tool: resolvePgTool('pg_dump', { explicit: params.pgDump, binDir: params.pgBinDir }),
+            args: ['--format=custom', '--no-owner', '--no-acl'],
+            outputFd: backupFd,
+            env: pgEnv,
+        });
+        if (dump.exitCode !== 0) {
+            throw new Error(`community_native_backup_dump_failed:exit_${String(dump.exitCode ?? 'null')}`);
+        }
+        const hashed = hashHeldFile(backupFd);
+        const verifyFd = openBackupForVerify({
+            backupPath,
+            writtenFd: backupFd,
+            expectedByteLength: hashed.byteLength,
+        });
+        try {
+            const verify = await run({
+                tool: resolvePgTool('pg_restore', { explicit: params.pgRestore, binDir: params.pgBinDir }),
+                args: ['--list'],
+                inputFd: verifyFd,
+            });
+            if (verify.exitCode !== 0) {
+                throw new Error(`community_native_backup_verify_failed:exit_${String(verify.exitCode ?? 'null')}`);
+            }
+        }
+        finally {
+            try {
+                closeSync(verifyFd);
+            }
+            catch { }
+        }
+        assertBackupUnchanged({
+            heldFd: backupFd,
+            expectedSha256: hashed.sha256,
+            expectedByteLength: hashed.byteLength,
+        });
+        const record = {
+            schemaVersion: 1,
+            kind: 'native-pg-custom',
+            path: backupPath,
+            sha256: hashed.sha256,
+            byteLength: hashed.byteLength,
+            verified: true,
+            verifiedBy: 'pg-restore-list',
+            createdAt: now().toISOString(),
+            instanceName: params.instanceName,
+            releaseVersion: params.releaseVersion ?? null,
+        };
+        const receiptPath = `${backupPath}.json`;
+        if (existsSync(receiptPath))
+            throw new Error('community_native_backup_receipt_already_exists');
+        writeFileSync(receiptPath, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+        keep = true;
+        return { record, receiptPath };
+    }
+    finally {
+        try {
+            closeSync(backupFd);
+        }
+        catch { }
+        if (!keep) {
+            try {
+                const { unlinkSync } = await import('node:fs');
+                unlinkSync(backupPath);
+            }
+            catch { }
+        }
+    }
+}
+export async function restoreCommunityNativeBackupV1(params) {
+    if (params.confirmDataRewind !== true) {
+        throw new Error('community_native_restore_confirmation_required:pass_--confirm-data-rewind');
+    }
+    if (params.skipPreRestoreBackup === true && params.confirmNoUndo !== true) {
+        throw new Error('community_native_restore_no_undo_confirmation_required:pass_--confirm-no-undo');
+    }
+    const run = params.runProcess ?? runNativePgProcess;
+    const receiptPath = `${params.backupPath}.json`;
+    if (!existsSync(receiptPath))
+        throw new Error('community_native_backup_receipt_missing');
+    let record;
+    try {
+        record = JSON.parse(readFileSync(receiptPath, 'utf8'));
+    }
+    catch {
+        throw new Error('community_native_backup_receipt_unreadable');
+    }
+    if (record?.kind !== 'native-pg-custom' || record.schemaVersion !== 1 || record.verified !== true) {
+        throw new Error('community_native_backup_receipt_invalid');
+    }
+    if (path.resolve(String(record.path)) !== path.resolve(params.backupPath)) {
+        throw new Error('community_native_backup_receipt_path_mismatch');
+    }
+    const noFollow = typeof constants.O_NOFOLLOW === 'number' ? constants.O_NOFOLLOW : 0;
+    const archiveFd = openSync(params.backupPath, constants.O_RDONLY | noFollow);
+    let preRestoreBackup = null;
+    try {
+        const pgEnv = pgEnvironmentFromUrl(params.repoUrl);
+        const probeFd = openBackupForVerify({
+            backupPath: params.backupPath,
+            writtenFd: archiveFd,
+            expectedByteLength: record.byteLength,
+        });
+        let rewindPlan;
+        try {
+            rewindPlan = await resolveSchemaRewindPlan({
+                repoUrl: params.repoUrl,
+                archivePath: params.backupPath,
+                archiveFd: probeFd,
+                pgBinDir: params.pgBinDir,
+                psql: params.psql,
+                pgRestore: params.pgRestore,
+                captureOutput: params.captureSchemaProbe,
+            });
+        }
+        finally {
+            try {
+                closeSync(probeFd);
+            }
+            catch { }
+        }
+        if (params.skipPreRestoreBackup !== true) {
+            const taken = await createCommunityNativeBackupV1({
+                backupRoot: params.backupRoot,
+                repoUrl: params.repoUrl,
+                instanceName: params.instanceName,
+                releaseVersion: params.releaseVersion ?? null,
+                pgBinDir: params.pgBinDir,
+                pgDump: params.pgDump,
+                pgRestore: params.pgRestore,
+                now: params.now,
+                runProcess: params.runProcess,
+            });
+            preRestoreBackup = {
+                path: taken.record.path,
+                sha256: taken.record.sha256,
+                byteLength: taken.record.byteLength,
+            };
+        }
+        verifyHeldBackupAgainstReceipt({ heldFd: archiveFd, receipt: record });
+        const rewind = await run({
+            tool: resolvePgTool('psql', { explicit: params.psql, binDir: params.pgBinDir }),
+            args: [
+                '--dbname', String(pgEnv.PGDATABASE),
+                '--set', 'ON_ERROR_STOP=1',
+                '--quiet',
+                '--command',
+                `${rewindPlan.drop.map((name) => `DROP SCHEMA IF EXISTS ${quoteSchemaIdentifier(name)} CASCADE;`).join(' ')} CREATE SCHEMA public;`,
+            ],
+            env: pgEnv,
+        });
+        if (rewind.exitCode !== 0) {
+            throw new Error(`community_native_restore_rewind_failed:exit_${String(rewind.exitCode ?? 'null')}`);
+        }
+        const restore = await run({
+            tool: resolvePgTool('pg_restore', { explicit: params.pgRestore, binDir: params.pgBinDir }),
+            args: [
+                '--dbname', String(pgEnv.PGDATABASE),
+                '--no-owner', '--no-acl', '--exit-on-error',
+            ],
+            inputFd: archiveFd,
+            env: pgEnv,
+        });
+        if (restore.exitCode !== 0) {
+            throw new Error(`community_native_restore_failed:exit_${String(restore.exitCode ?? 'null')}`);
+        }
+    }
+    finally {
+        try {
+            closeSync(archiveFd);
+        }
+        catch { }
+    }
+    return { restored: record, preRestoreBackup };
+}