borgmcp 2.10.2 → 2.11.0

package/src/enrollment-lock.ts

@@ -0,0 +1,53 @@
+import { createHash } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { withStoreLock } from './seat-store.js';
+import { BORG_USER_ROOT, SERVER_CREDENTIALS_FILE } from './credential-paths.js';
+
+const processTails = new Map<string, Promise<void>>();
+const heldOrigins = new AsyncLocalStorage<ReadonlySet<string>>();
+
+function enrollmentLockPath(origin: string): string {
+  const binding = createHash('sha256').update(origin).digest('hex');
+  return `${SERVER_CREDENTIALS_FILE}.enrollment-${binding}.lock`;
+}
+
+async function withProcessOriginLock<T>(origin: string, operation: () => Promise<T>): Promise<T> {
+  const prior = processTails.get(origin) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => { release = resolve; });
+  const tail = prior.then(() => current);
+  processTails.set(origin, tail);
+  await prior;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (processTails.get(origin) === tail) processTails.delete(origin);
+  }
+}
+
+/**
+ * Serialize every authoritative enrollment read, commit, and recovery for one
+ * server origin. The in-process queue also covers injected test backends; the
+ * file lock is the cross-process authority in production.
+ */
+export async function withEnrollmentOriginLock<T>(
+  origin: string,
+  operation: () => Promise<T>,
+  options: { processShared?: boolean } = {},
+): Promise<T> {
+  const held = heldOrigins.getStore();
+  if (held?.has(origin)) return operation();
+  return withProcessOriginLock(origin, async () => {
+    const run = () => heldOrigins.run(new Set([...(held ?? []), origin]), operation);
+    if (options.processShared === false) return run();
+    return withStoreLock(enrollmentLockPath(origin), run, {
+        secureRoot: BORG_USER_ROOT,
+        rootMode: 'owner-controlled',
+      });
+  });
+}
+
+export function __clearEnrollmentOriginLocksForTest(): void {
+  processTails.clear();
+}

package/src/enrollment-types.ts

@@ -0,0 +1,51 @@
+export interface EnrollmentTrustPointer {
+  version: 1;
+  origin: string;
+  generationId: string;
+  trustIdentity: string;
+}
+
+export interface EnrollmentArtifactBinding {
+  artifactFormatVersion: number;
+  artifactDigest: string;
+  endpoint: string;
+  caSpkiSha256: string;
+  trustIdentity: string;
+  expectedAuthority: 'owner' | 'client';
+  stagedGenerationId: string;
+}
+
+export interface EnrollmentReplacementCapability {
+  token: string;
+  priorAccountsDigest: string;
+  endpoint: string;
+  caSpkiSha256: string;
+  trustIdentity: string;
+  retryKey: string;
+  artifactDigest: string;
+}
+
+export interface EnrollmentRollbackSnapshot {
+  activeAccounts: Record<string, string>;
+  pendingAccount: string;
+  pendingValue: string;
+}
+
+export interface EnrollmentRollbackRecord {
+  version: 1;
+  state: 'rollback-snapshot';
+  origin: string;
+  snapshot: EnrollmentRollbackSnapshot;
+}
+
+export interface AcceptedEnrollmentMarker {
+  version: 1;
+  state: 'accepted';
+  origin: string;
+  trustIdentity: string;
+  generationId: string;
+  previousPointer: EnrollmentTrustPointer | null;
+  activeDigest: string;
+  rollbackAccount: string;
+  rollbackDigest: string;
+}

package/src/index.ts

@@ -1017,7 +1017,7 @@ export async function main() {
           if (typeof args?.name === 'string') updates.name = args.name as string;
           if (typeof args?.cube_directive === 'string') updates.cube_directive = args.cube_directive as string;
           if (Array.isArray(args?.message_taxonomy)) updates.message_taxonomy = args.message_taxonomy as MessageTaxonomy;
-          if (Object.keys(updates).length === 0) throw new Error('Pass at least one of: name, cube_directive, message_taxonomy.');
+          if (Object.keys(updates).length === 0) throw new Error('Pass at least one of: cube_directive, message_taxonomy.');
           const { cube } = await updateCube(cubeId, updates);
           return { content: [{ type: 'text', text: `Updated cube **${cube.name}** (id: ${cube.id}).` }] };
         }

package/src/invitation-artifact.ts

@@ -22,7 +22,13 @@ export const STORAGE_INVITATION_ERROR =
   'Borg could not prepare local trust state for this invitation. No invitation or credential was sent and no local trust or credential state was changed. Check that Borg can write its private local state, then retry.';
 
 export const RECOVERY_INVITATION_ERROR =
-  'Borg could not complete or undo the enrollment change. Prior local access may be unavailable. Run `borg recover-enrollment` to clear only this server enrollment transaction. The invitation used for this attempt has been consumed; after recovery, ask the server operator for a fresh invitation and retry.';
+  'Borg could not complete or undo the enrollment change. Prior local access may be unavailable. Run `borg recover-enrollment` to restore or clear only this server enrollment transaction; it does not change unrelated server enrollments or accounts. The invitation used for this attempt has been consumed; after recovery, ask the server operator for a fresh invitation and retry.';
+
+export const MISKEYED_RECOVERY_ERROR =
+  'Borg found a failed enrollment record where it does not belong. No state was changed. This release has no supported way to recover that record; keep it intact.';
+
+export const RECOVERY_TRANSACTION_CHANGED_ERROR =
+  'The failed enrollment transaction you reviewed is no longer present. No state was changed. Re-run `borg recover-enrollment` to review the current transaction.';
 
 export class InvitationArtifactCompatibilityError extends Error {
   constructor(message = COMPATIBILITY_INVITATION_ERROR) {

package/src/recover-enrollment-cmd.ts

@@ -1,6 +1,11 @@
 import { normalizeServerEndpoint } from './server-endpoint.js';
-import { clearEnrollmentTransaction, findPendingServerEnrollment } from './config.js';
-import { clearBorgServerTrust } from './server-trust.js';
+import { clearEnrollmentTransaction, findEnrollmentRecoveryTransaction } from './config.js';
+import {
+  InvitationArtifactRecoveryError,
+  RECOVERY_TRANSACTION_CHANGED_ERROR,
+} from './invitation-artifact.js';
+import { withEnrollmentOriginLock } from './enrollment-lock.js';
+import { clearStagedBorgServerTrust, restoreBorgServerEnrollment } from './server-trust.js';
 
 export interface RecoverEnrollmentFlags {
   host?: string;
@@ -31,33 +36,52 @@ export async function runRecoverEnrollment(
   flags: RecoverEnrollmentFlags,
   deps: { prompt: (message: string) => Promise<string>; stderr: (line: string) => void; stdout: (line: string) => void },
 ): Promise<number> {
-  const pending = await findPendingServerEnrollment();
-  if (!pending) {
-    deps.stderr('No recoverable Borg enrollment transaction was found. No state was changed.\n');
-    return 1;
-  }
-  let origin = pending.origin;
+  let selectedOrigin: string | undefined;
   if (flags.host !== undefined) {
-    try { origin = normalizeServerEndpoint(flags.host); } catch (error) {
+    try { selectedOrigin = normalizeServerEndpoint(flags.host); } catch (error) {
       deps.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
       return 1;
     }
-    if (origin !== pending.origin) {
-      deps.stderr('The recovery host does not match the failed enrollment transaction. No state was changed.\n');
+  }
+  const transaction = await findEnrollmentRecoveryTransaction(selectedOrigin);
+  if (!transaction) {
+    if (selectedOrigin !== undefined && await findEnrollmentRecoveryTransaction()) {
+      deps.stderr('The recovery host does not match the failed enrollment transaction. No state was changed. Re-run without `--host` to review the current transaction.\n');
       return 1;
     }
+    deps.stderr('No recoverable Borg enrollment transaction was found. No state was changed.\n');
+    return 1;
   }
+  const enrollment = transaction.kind === 'accepted' ? transaction.marker : transaction.pending;
+  const origin = enrollment.origin;
   if (!flags.yes) {
     const answer = await deps.prompt(
-      `Clear only the failed enrollment for ${origin}? Other server enrollments and accounts will not be touched. [y/N]: `,
+      `${transaction.kind === 'accepted' ? 'Restore the prior enrollment' : 'Clear the failed enrollment transaction'} for ${origin}? Other server enrollments and accounts will not be touched. [y/N]: `,
     );
     if (!/^y(?:es)?$/i.test(answer.trim())) {
       deps.stderr('Enrollment recovery was not confirmed. No state was changed.\n');
       return 1;
     }
   }
-  await clearEnrollmentTransaction(origin, pending.trustIdentity);
-  await clearBorgServerTrust(origin);
-  deps.stdout(`Cleared the failed enrollment transaction for ${origin}; other server enrollments and accounts were left unchanged.\n`);
+  await withEnrollmentOriginLock(origin, async () => {
+    if (transaction.kind === 'accepted') {
+      if (!await restoreBorgServerEnrollment(transaction.marker)) {
+        throw new InvitationArtifactRecoveryError(RECOVERY_TRANSACTION_CHANGED_ERROR);
+      }
+      return;
+    }
+    if (!await clearEnrollmentTransaction(transaction.pending)) {
+      throw new InvitationArtifactRecoveryError(RECOVERY_TRANSACTION_CHANGED_ERROR);
+    }
+    await clearStagedBorgServerTrust(
+      origin,
+      transaction.pending.artifactBinding?.stagedGenerationId,
+    );
+  });
+  if (transaction.kind === 'accepted') {
+    deps.stdout(`Restored the prior enrollment state for ${origin}; other server enrollments and accounts were left unchanged.\n`);
+  } else {
+    deps.stdout(`Cleared the failed enrollment transaction for ${origin}; other server enrollments and accounts were left unchanged.\n`);
+  }
   return 0;
 }

package/src/remote-client.ts

@@ -45,6 +45,7 @@ import type { FragmentView, NonClobberSyncResult } from './sync-roles-render.js'
 import type { WorkingRepo } from './working-repo.js';
 import { buildRuntimeMetadataPatch } from './runtime-metadata.js';
 import { loadBorgServerTrust, type ServerFetch } from './server-trust.js';
+import { withEnrollmentOriginLock } from './enrollment-lock.js';
 import {
   BorgServerError,
   BorgServerHttpError,
@@ -54,6 +55,7 @@ import {
   CubeDeletionConfirmationError,
   LocalManageCredentialUnavailableError,
   LocalManageRequiredError,
+  LocalUnsupportedError,
 } from './server-errors.js';
 import { getActiveCube, type ActiveCube } from './cubes.js';
 import { markSeatRejected } from './seats.js';
@@ -190,7 +192,7 @@ async function localAuthorityContext(
 }
 
 function localUnsupported(capability: string): never {
-  throw new Error(`Local Borg server does not support ${capability}`);
+  throw new LocalUnsupportedError(capability);
 }
 
 function waitForLocalRequest<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
@@ -633,7 +635,13 @@ async function authedFetch(
   let requestFetch: ServerFetch;
   let token: string;
   {
-    const trust = await loadBorgServerTrust(baseUrl);
+    const pair = droneSession === undefined && authToken === undefined
+      ? await withEnrollmentOriginLock(baseUrl, async () => ({
+          trust: await loadBorgServerTrust(baseUrl),
+          stored: await getServerCredential(baseUrl, serverTrustIdentity),
+        }))
+      : { trust: await loadBorgServerTrust(baseUrl), stored: null };
+    const trust = pair.trust;
     if (trust.identity !== serverTrustIdentity) {
       // CR5: a TYPED terminal trust verdict — never inferred from error text.
       throw new BorgServerTrustError('Borg server trust identity changed; refusing the connection');
@@ -646,7 +654,7 @@ async function authedFetch(
     } else if (authToken !== undefined) {
       token = authToken;
     } else {
-      const stored = await getServerCredential(baseUrl, serverTrustIdentity);
+      const stored = pair.stored;
       if (!stored) {
         throw new Error('No credential is stored for the selected Borg server identity');
       }
@@ -1012,11 +1020,28 @@ export async function removeDecision(
   selector: { topic: string } | { decision_id: string },
   serverTrustIdentity?: string,
 ): Promise<{ decision: any }> {
-  void sessionToken;
-  void apiUrl;
-  void selector;
-  void serverTrustIdentity;
-  localUnsupported('decision removal');
+  const local = await localAuthorityContext(sessionToken, apiUrl, serverTrustIdentity);
+  let payload: { decision: any } | null;
+  try {
+    payload = await localManageRequest<{ decision: any }>(
+      local,
+      `/api/cubes/${local.cubeId}/decisions`,
+      'DELETE',
+      {
+        operation: `remove a decision from cube ${manageCopyValue(local.name)}`,
+        cubeName: local.name,
+        noMutation: 'No decision was removed.',
+      },
+      selector,
+    );
+  } catch (error) {
+    if (error instanceof BorgServerHttpError && error.status === 404) {
+      localUnsupported('decision removal');
+    }
+    throw error;
+  }
+  if (!payload) throw new Error('Local Borg server returned an empty decision removal response');
+  return payload;
 }
 
 /**
@@ -1268,8 +1293,9 @@ export async function createCube(
 }
 
 /**
- * Update a cube's name and/or cube_directive. Both fields are optional;
- * pass only what changes.
+ * Update a cube's directive and/or message taxonomy. Rename is not supported
+ * by the local server API and remains an explicit typed failure for callers
+ * that bypass the public tool schema.
  */
 export async function updateCube(
   cubeId: string,

package/src/server-errors.ts

@@ -78,6 +78,13 @@ export class LocalManageCredentialUnavailableError extends Error {
   }
 }
 
+export class LocalUnsupportedError extends Error {
+  constructor(public readonly capability: string) {
+    super(`Local Borg server does not support ${capability}`);
+    this.name = 'LocalUnsupportedError';
+  }
+}
+
 /**
  * CR5: a STABLE TYPED terminal trust verdict — the pinned server identity no longer
  * matches. This is a security boundary: it must be classified from the error TYPE,