hoi4-agent-tools 0.1.7 → 1.0.0

package/dist/hoi4_agent_tools/core/transactions.js

@@ -46,6 +46,7 @@ function sameTransactionManifestIdentity(left, right) {
         left.ctimeMs === right.ctimeMs);
 }
 const transactionIdPattern = /^txn_[0-9a-f-]{36}$/u;
+const journalReclamationPattern = /^\.reclaiming-txn_[0-9a-f-]{36}$/u;
 const lockOwnerGraceMs = 30_000;
 const lockHost = hostname().toLowerCase();
 const lockInstanceId = secureId('instance');
@@ -442,30 +443,6 @@ export class TransactionManager {
             }
         });
     }
-    async rollback(workspaceId, transactionId, expectedPlanHash, principal, signal) {
-        signal?.throwIfAborted();
-        const workspace = this.resolver.get(workspaceId, principal);
-        if (!workspace.writeEnabled)
-            throw new ServiceError('WRITE_POLICY_DISABLED', 'Workspace writes are not enabled');
-        const manifest = await this.load(workspace, transactionId, {
-            headMode: 'reconcile',
-            ...(signal === undefined ? {} : { signal }),
-        });
-        this.assertBinding(manifest, workspace, expectedPlanHash, principal);
-        if (manifest.state !== 'applied')
-            throw new ServiceError('TRANSACTION_NOT_APPLIED', 'Only applied transactions can be rolled back');
-        return this.withWorkspaceLock(workspace, transactionId, async () => {
-            signal?.throwIfAborted();
-            await this.verifyCurrentFiles(workspace, manifest, 'after', principal, signal);
-            signal?.throwIfAborted();
-            // Restoring source bytes and advancing the authenticated journal are one
-            // non-cancellable critical phase once preflight has completed.
-            await this.restoreBeforeState(workspace, manifest, principal);
-            manifest.state = 'rolled_back';
-            await this.writeManifest(workspace, manifest);
-            return manifest;
-        });
-    }
     async status(workspaceId, transactionId, principal, signal) {
         signal?.throwIfAborted();
         const manifest = await this.load(this.resolver.get(workspaceId, principal), transactionId, {
@@ -546,6 +523,7 @@ export class TransactionManager {
             await this.removeOrphanJournalHeads(workspace, new Set(), signal);
             return [];
         }
+        await this.removeReclamationDirectories(directory, signal);
         const directoryEntries = await readdir(directory, { withFileTypes: true });
         signal?.throwIfAborted();
         const transactionIds = new Set(directoryEntries
@@ -746,7 +724,7 @@ export class TransactionManager {
             await mkdir(transactionsDirectory, { recursive: true });
             transactionsDirectory = await containedGeneratedPath(workspace.cacheRoot, 'transactions');
             await this.pruneExpiredJournals(workspace, transactionsDirectory);
-            const usage = await this.journalUsage(transactionsDirectory);
+            let usage = await this.journalUsage(transactionsDirectory);
             this.authenticateManifest(manifest);
             const serializedManifest = `${canonicalJson(manifest)}\n`;
             if (Buffer.byteLength(serializedManifest, 'utf8') > TRANSACTION_MAX_MANIFEST_BYTES) {
@@ -756,11 +734,18 @@ export class TransactionManager {
             const prospectiveBytes = blobBytes + Buffer.byteLength(serializedManifest, 'utf8');
             const replacementBytes = manifest.files.reduce((total, file) => total + (file.beforeSize ?? 0) + (file.afterSize ?? 0), 0);
             const transactionWorkBytes = prospectiveBytes + replacementBytes;
+            const retentionLimitReached = () => usage.count >= this.maxJournals || usage.bytes > this.maxJournalBytes - prospectiveBytes;
+            if (Number.isSafeInteger(prospectiveBytes) &&
+                Number.isSafeInteger(transactionWorkBytes) &&
+                transactionWorkBytes <= this.maxJournalBytes &&
+                retentionLimitReached()) {
+                await this.pruneExpiredJournals(workspace, transactionsDirectory, true);
+                usage = await this.journalUsage(transactionsDirectory);
+            }
             if (!Number.isSafeInteger(prospectiveBytes) ||
                 !Number.isSafeInteger(transactionWorkBytes) ||
-                usage.count >= this.maxJournals ||
-                transactionWorkBytes > this.maxJournalBytes ||
-                usage.bytes > this.maxJournalBytes - prospectiveBytes) {
+                retentionLimitReached() ||
+                transactionWorkBytes > this.maxJournalBytes) {
                 throw new ServiceError('TRANSACTION_JOURNAL_LIMIT', 'Transaction journal retention limit has been reached');
             }
             const transactionDirectory = await this.transactionDirectory(workspace, manifest.transactionId);
@@ -779,8 +764,9 @@ export class TransactionManager {
             }
         });
     }
-    async pruneExpiredJournals(workspace, transactionsDirectory) {
+    async pruneExpiredJournals(workspace, transactionsDirectory, reclaimApplied = false) {
         const now = Date.now();
+        await this.removeReclamationDirectories(transactionsDirectory);
         const entries = await readdir(transactionsDirectory, { withFileTypes: true });
         const cacheTransactionIds = new Set(entries.filter((entry) => transactionIdPattern.test(entry.name)).map((entry) => entry.name));
         await this.removeOrphanJournalHeads(workspace, cacheTransactionIds);
@@ -811,6 +797,7 @@ export class TransactionManager {
                     try {
                         const orphan = await this.load(workspace, entry.name, { headMode: 'none' });
                         if (orphan.state === 'planned' || orphan.state === 'rolled_back') {
+                            this.removeManifestByteCache(this.manifestCacheKey(workspace, entry.name));
                             await rm(directory, { recursive: true, force: true });
                             continue;
                         }
@@ -821,7 +808,10 @@ export class TransactionManager {
                 }
                 continue;
             }
-            if (Date.parse(manifest.expiresAt) <= now &&
+            if (reclaimApplied && manifest.state === 'applied') {
+                await this.reclaimAutonomousAppliedJournal(workspace, transactionsDirectory, entry.name);
+            }
+            else if (Date.parse(manifest.expiresAt) <= now &&
                 (manifest.state === 'planned' || manifest.state === 'rolled_back')) {
                 // Removing protected state first makes a crash or later cache replay fail closed.
                 await this.requireServerState().removeJournalHead(workspace.workspaceIdentity, entry.name);
@@ -829,6 +819,32 @@ export class TransactionManager {
             }
         }
     }
+    async reclaimAutonomousAppliedJournal(workspace, transactionsDirectory, transactionId) {
+        const directory = await this.transactionDirectory(workspace, transactionId);
+        const reclamationDirectory = await containedGeneratedPath(transactionsDirectory, `.reclaiming-${transactionId}`);
+        // The atomic rename is the durable reclamation marker. It moves the journal
+        // outside quota and recovery scans before protected state is removed, so a
+        // restart can finish cleanup under any later write policy without mistaking
+        // an unrelated headless applied journal for authorized reclamation.
+        this.removeManifestByteCache(this.manifestCacheKey(workspace, transactionId));
+        await rename(directory, reclamationDirectory);
+        await this.requireServerState().removeJournalHead(workspace.workspaceIdentity, transactionId);
+        await rm(reclamationDirectory, { recursive: true, force: true });
+    }
+    async removeReclamationDirectories(transactionsDirectory, signal) {
+        for (const entry of await readdir(transactionsDirectory, { withFileTypes: true })) {
+            signal?.throwIfAborted();
+            if (!journalReclamationPattern.test(entry.name))
+                continue;
+            if (entry.isSymbolicLink() || !entry.isDirectory()) {
+                throw new ServiceError('TRANSACTION_JOURNAL_UNSAFE', 'Transaction journal reclamation contains an unsafe entry');
+            }
+            await rm(await containedGeneratedPath(transactionsDirectory, entry.name), {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
     async removeOrphanJournalHeads(workspace, cacheTransactionIds, signal) {
         if (this.serverState === undefined)
             return;
@@ -1178,4 +1194,3 @@ export class TransactionManager {
         return true;
     }
 }
-//# sourceMappingURL=transactions.js.map