@hivemagnus/magnus-server 1.1.3 → 1.1.5

package/agent-version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.1.3"
+  "version": "1.1.5"
 }

package/dist/cli/migrations.js

@@ -239,17 +239,40 @@ export async function restoreDatabase(options) {
     });
     if (listed.code !== 0)
         throw new Error(`${options.file} is not a readable dump: ${(listed.stderr || listed.stdout).trim().split('\n').slice(-2).join(' ')}`);
+    // A schema left aside by an earlier restore means that restore was interrupted (or could not drop
+    // it): the original data may only exist there, so never swap again on top of it.
+    const leftover = await options.client.query("SELECT nspname FROM pg_namespace WHERE nspname LIKE 'magnus\\_pre\\_restore\\_%' ORDER BY nspname");
+    if (leftover.rows.length) {
+        const names = leftover.rows.map(row => row.nspname).join(', ');
+        throw new Error(`an earlier restore left the schema ${names} behind, which may hold the original data. Check what \`public\` holds; `
+            + `to put the set-aside schema back run \`${restoreRevertSql(leftover.rows.at(-1).nspname)}\`, or drop it once you are sure it is not needed, then restore again.`);
+    }
     const aside = restoreAsideSchema(options.now ?? new Date());
     await options.client.query(restoreSwapSql(aside));
     log(`  moved the current schema aside as ${aside}`);
+    // From here on every failure must put the original schema back before it is reported.
+    const putBack = async (reason) => {
+        try {
+            await options.client.query(restoreRevertSql(aside));
+        }
+        catch (error) {
+            throw new Error(`${reason}, and putting the original schema back failed too; it is kept as ${aside}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        throw new Error(`${reason}; the database is unchanged`);
+    };
     const { url, env } = splitPassword(options.databaseUrl);
-    const result = await run(pgRestore, ['--single-transaction', '--exit-on-error', '--no-owner', '--dbname', url, options.file], { capture: true, env: { ...process.env, ...env } });
-    if (result.code !== 0) {
-        await options.client.query(restoreRevertSql(aside)).catch((error) => {
-            throw new Error(`pg_restore failed and putting the original schema back failed too; it is kept as ${aside}: ${error instanceof Error ? error.message : String(error)}`);
-        });
-        throw new Error(`pg_restore failed (exit ${result.code}); the database is unchanged: ${result.stderr.trim().split('\n').slice(-3).join(' ')}`);
+    let result;
+    try {
+        result = await run(pgRestore, ['--single-transaction', '--exit-on-error', '--no-owner', '--dbname', url, options.file], { capture: true, env: { ...process.env, ...env } });
     }
-    await options.client.query(restoreFinishSql(aside));
+    catch (error) {
+        return putBack(`${pgRestore} could not be run (${error instanceof Error ? error.message : String(error)})`);
+    }
+    if (result.code !== 0)
+        return putBack(`pg_restore failed (exit ${result.code}): ${result.stderr.trim().split('\n').slice(-3).join(' ')}`);
+    // The restore committed; failing to drop the old copy must not report the restore as failed.
+    await options.client.query(restoreFinishSql(aside)).catch((error) => {
+        log(`  warning: the restore succeeded but the previous schema ${aside} could not be dropped (${error instanceof Error ? error.message : String(error)}); drop it with \`${restoreFinishSql(aside)}\` once you have checked the restored data`);
+    });
 }
 //# sourceMappingURL=migrations.js.map

package/dist/services/resource-enrollment.js

@@ -163,10 +163,12 @@ export const PARTICIPANT_RECEIPT_LIMITS = { default: 16_384, scheduler: 256 * 10
 export class ParticipantEvidenceError extends Error {
     code;
     agentCode;
-    constructor(code, agentCode = null) {
+    agentReason;
+    constructor(code, agentCode = null, agentReason = null) {
         super(code);
         this.code = code;
         this.agentCode = agentCode;
+        this.agentReason = agentReason;
     }
 }
 const failures = new Map();
@@ -177,20 +179,24 @@ export function lastParticipantFailures(nodeId) {
 /** Bounded response consumption, including dishonest or absent content-length. */
 export async function readParticipantReceipt(response, limit = PARTICIPANT_RECEIPT_LIMITS.default) {
     if (response.status !== 200 || !response.body) {
-        // An optional machine-readable code from the participant (`{ error: { code } }`) is kept; nothing else is.
+        // An optional machine-readable code and fixed reason from the participant
+        // (`{ error: { code, reason } }`) are kept; nothing else is.
         let agentCode = null;
+        let agentReason = null;
         if (response.body && response.status >= 400) {
             const text = await response.text().catch(() => '');
             try {
-                const code = JSON.parse(text.slice(0, 4096))?.error?.code;
-                if (typeof code === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(code))
-                    agentCode = code;
+                const error = JSON.parse(text.slice(0, 4096))?.error;
+                if (typeof error?.code === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(error.code))
+                    agentCode = error.code;
+                if (typeof error?.reason === 'string' && /^[a-z][a-z0-9-]{0,47}$/.test(error.reason))
+                    agentReason = error.reason;
             }
             catch { /* no code */ }
         }
         else
             await response.body?.cancel().catch(() => undefined);
-        throw new ParticipantEvidenceError(`participant-http-${response.status}`, agentCode);
+        throw new ParticipantEvidenceError(`participant-http-${response.status}`, agentCode, agentReason);
     }
     const reader = response.body.getReader();
     const chunks = [];
@@ -280,8 +286,9 @@ export async function refreshEnrollmentParticipant(nodeId, participant) {
         // Outstanding challenge remains pending.
         const cause = error instanceof ParticipantEvidenceError ? error.code : 'participant-evidence-unavailable';
         const agentCode = error instanceof ParticipantEvidenceError ? error.agentCode : null;
-        failures.set(`${nodeId}\n${participant}`, { participant, cause, agentCode, at: new Date().toISOString() });
-        return { participant, status: 'pending', reason: 'participant-evidence-unavailable', cause, agentCode };
+        const agentReason = error instanceof ParticipantEvidenceError ? error.agentReason : null;
+        failures.set(`${nodeId}\n${participant}`, { participant, cause, agentCode, agentReason, at: new Date().toISOString() });
+        return { participant, status: 'pending', reason: 'participant-evidence-unavailable', cause, agentCode, agentReason };
     }
     failures.delete(`${nodeId}\n${participant}`);
     return getDb().$transaction(async (tx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hivemagnus/magnus-server",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Magnus server: the fleet control plane API (Hono, PostgreSQL, Redis) for nodes running magnus-agent, with optional Hive IAM, Hive Router, HiveMem, Hermes Agent and external security console integrations.",
   "keywords": [
     "magnus",
@@ -84,7 +84,7 @@
     "prepublishOnly": "npm run db:generate && npm run clean && npm run build"
   },
   "dependencies": {
-    "@hivemagnus/magnus-contracts": "1.1.3",
+    "@hivemagnus/magnus-contracts": "1.1.5",
     "@hono/node-server": "^2.1.5",
     "@hono/swagger-ui": "^0.6.2",
     "@prisma/adapter-pg": "7.10.1",
@@ -102,7 +102,7 @@
     "ws": "^8.22.0",
     "yaml": "2.9.1",
     "zod": "^4.6.7",
-    "@hivemagnus/magnus-skills": "1.1.3",
+    "@hivemagnus/magnus-skills": "1.1.5",
     "prisma": "^7.10.1"
   },
   "devDependencies": {