borgmcp 2.3.0 → 2.4.1

package/src/reset-local-seat-cmd.ts

@@ -25,6 +25,7 @@ import { createInterface } from 'node:readline/promises';
 import {
   snapshotLocalSeat as cubesSnapshotLocalSeat,
   resetLocalSeatBinding as cubesResetLocalSeatBinding,
+  findRemainingActiveSeatForWorktree as cubesFindRemainingActiveSeatForWorktree,
   findProjectRoot as cubesFindProjectRoot,
   type LocalSeatSnapshot,
   type ResetLocalSeatOutcome,
@@ -39,6 +40,10 @@ export interface ResetLocalSeatFlags {
 export interface ResetLocalSeatDeps {
   snapshotLocalSeat: () => Promise<LocalSeatSnapshot | null>;
   resetLocalSeatBinding: (expected: LocalSeatSnapshot) => Promise<ResetLocalSeatOutcome>;
+  findRemainingActiveSeat: (worktree: string) => Promise<{
+    apiUrl: string;
+    operation: { projectRoot: string; kind: 'seat' | 'sibling'; operationKey: string };
+  } | null>;
   findProjectRoot: (cwd: string) => string;
   normalizeHost: (host: string) => string;
   cwd: () => string;
@@ -52,6 +57,10 @@ function reenrollCommand(apiUrl: string): string {
   return `\`borg assimilate --host ${apiUrl} --enroll\``;
 }
 
+function reattachCommand(apiUrl: string): string {
+  return `\`borg assimilate --host ${apiUrl} --here\``;
+}
+
 /**
  * Recovery guidance shared by the success + honest-no-op copy. Makes NO
  * server-revocation claim: it recommends the operator issue a LIVE scoped
@@ -149,7 +158,22 @@ export async function runResetLocalSeat(
       `audit: this worktree's saved local seat for ${snapshot.apiUrl} (worktree ${worktree}) ` +
         'was cleared; server, trust anchor, cube, and sibling worktrees unchanged.\n',
     );
-    deps.stdout(recoveryGuidance(snapshot.apiUrl));
+    let remaining: Awaited<ReturnType<ResetLocalSeatDeps['findRemainingActiveSeat']>> = null;
+    try {
+      remaining = await deps.findRemainingActiveSeat(worktree);
+    } catch {
+      // The reset already committed. A follow-up read must not turn that success
+      // into a false failure; fall back to the universally valid enrollment path.
+    }
+    if (remaining?.apiUrl === snapshot.apiUrl) {
+      deps.stdout(
+        `Another saved active seat remains for this worktree on ${snapshot.apiUrl}. ` +
+          `Re-attach with ${reattachCommand(snapshot.apiUrl)}; Borg will revalidate that ` +
+          'seat with the server before launch.\n',
+      );
+    } else {
+      deps.stdout(recoveryGuidance(snapshot.apiUrl));
+    }
     return 0;
   }
 
@@ -175,6 +199,7 @@ export function buildDefaultResetLocalSeatDeps(): ResetLocalSeatDeps {
   return {
     snapshotLocalSeat: () => cubesSnapshotLocalSeat(),
     resetLocalSeatBinding: (expected) => cubesResetLocalSeatBinding(expected),
+    findRemainingActiveSeat: (worktree) => cubesFindRemainingActiveSeatForWorktree(worktree),
     findProjectRoot: (cwd) => cubesFindProjectRoot(cwd),
     normalizeHost: (host) => normalizeServerEndpoint(host),
     cwd: () => process.cwd(),

package/src/seat-reattach-guard.ts

@@ -0,0 +1,113 @@
+import { readFileSync, statSync } from 'node:fs';
+import {
+  HEARTBEAT_STALE_MS,
+  heartbeatPathFor,
+  legacyHeartbeatPathFor,
+  legacyPidfilePathFor,
+  pidfilePathFor,
+} from './inbox-monitor.js';
+
+export type MonitorHeartbeatState = 'fresh' | 'stale' | 'missing';
+
+export interface LiveInboxMonitor {
+  pid: number;
+  heartbeat: MonitorHeartbeatState;
+}
+
+export interface SeatReattachGuardDeps {
+  readPidfile: (path: string) => string | null;
+  readHeartbeatMtimeMs: (path: string) => number | null;
+  isAlive: (pid: number) => boolean;
+  now: number;
+  heartbeatStaleMs?: number;
+}
+
+function parseMonitorPid(raw: string | null): number | null {
+  if (raw === null) return null;
+  const match = /^([1-9]\d*)(?::[^:\s]+)?$/.exec(raw.trim());
+  if (!match) return null;
+  const pid = Number(match[1]);
+  return Number.isSafeInteger(pid) ? pid : null;
+}
+
+/**
+ * Read-only preflight for reusing a worktree seat. A live PID always blocks:
+ * a stale heartbeat may mean the holder is wedged, but only an explicit
+ * `--force` decision may launch a second session onto that seat.
+ */
+export function inspectLiveInboxMonitor(
+  inboxPath: string,
+  monitorStateRoot: string,
+  deps: SeatReattachGuardDeps = defaultSeatReattachGuardDeps(),
+): LiveInboxMonitor | null {
+  const candidates = [
+    {
+      pidfile: pidfilePathFor(inboxPath, monitorStateRoot),
+      heartbeat: heartbeatPathFor(inboxPath, monitorStateRoot),
+    },
+    {
+      pidfile: legacyPidfilePathFor(inboxPath),
+      heartbeat: legacyHeartbeatPathFor(inboxPath),
+    },
+  ];
+  const staleMs = deps.heartbeatStaleMs ?? HEARTBEAT_STALE_MS;
+  for (const candidate of candidates) {
+    const pid = parseMonitorPid(deps.readPidfile(candidate.pidfile));
+    if (pid === null || !deps.isAlive(pid)) continue;
+    const heartbeatMtime = deps.readHeartbeatMtimeMs(candidate.heartbeat);
+    return {
+      pid,
+      heartbeat: heartbeatMtime === null
+        ? 'missing'
+        : deps.now - heartbeatMtime < staleMs
+          ? 'fresh'
+          : 'stale',
+    };
+  }
+  return null;
+}
+
+export function formatSeatReattachRefusal(
+  holder: LiveInboxMonitor,
+  forcedCommand: string,
+): string {
+  const heartbeat =
+    holder.heartbeat === 'fresh'
+      ? ''
+      : ` Its heartbeat is ${holder.heartbeat}, so the process may be wedged.`;
+  return (
+    `This worktree's Borg seat already has a live session (inbox monitor pid ${holder.pid}).${heartbeat}\n` +
+    'No agent was launched. Stop the existing session or use a fresh worktree with `borg assimilate --worktree <name>`. ' +
+    `If the live monitor is wedged, override once with \`${forcedCommand}\`.\n`
+  );
+}
+
+export function defaultSeatReattachGuardDeps(
+  now: number = Date.now(),
+): SeatReattachGuardDeps {
+  return {
+    readPidfile: (path) => {
+      try {
+        return readFileSync(path, 'utf8');
+      } catch {
+        return null;
+      }
+    },
+    readHeartbeatMtimeMs: (path) => {
+      try {
+        return statSync(path).mtimeMs;
+      } catch {
+        return null;
+      }
+    },
+    isAlive: (pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error: any) {
+        return error?.code === 'EPERM';
+      }
+    },
+    now,
+  };
+}

package/src/seats.ts

@@ -98,6 +98,8 @@ function emptyStore(): SeatsFile {
 
 const ROLE_CLASSES = new Set(['queen', 'worker']);
 const OPERATION_KINDS = new Set(['seat', 'sibling']);
+const SEAT_BEARER_RE = /^[A-Za-z0-9_-]{43,1024}$/;
+const rejectedSeatRefs = new Set<string>();
 
 function isNonEmptyString(value: unknown): value is string {
   return typeof value === 'string' && value.length > 0;
@@ -117,10 +119,10 @@ function isValidOperation(value: unknown): value is SeatOperation {
 /**
  * CR#2: FULL per-entry validation. Every key/value/invariant of a seat record is
  * checked — the ref is well-formed and self-consistent (the map key equals the
- * record's derived ref), state ∈ {pending,active}, the credential is a non-empty
- * string, the operation is well-shaped, an ACTIVE record carries ALL its required
- * server + binding fields, and a PENDING record carries NO active-only session
- * id. A single invalid entry ⇒ the whole store is rejected
+ * record's derived ref), state ∈ {pending,active}, the credential is an exact
+ * 32-byte base64url bearer, the operation is well-shaped, an ACTIVE record carries
+ * ALL its required server + binding fields, and a PENDING record carries NO
+ * active-only session id. A single invalid entry ⇒ the whole store is rejected
  * (fail closed at the caller, bytes preserved) — never a silent cast.
  */
 function isValidSeatRecord(ref: string, value: unknown): value is SeatRecord {
@@ -134,7 +136,8 @@ function isValidSeatRecord(ref: string, value: unknown): value is SeatRecord {
     !isNonEmptyString(r.cubeId) ||
     !isNonEmptyString(r.roleId) ||
     !isValidOperation(r.operation) ||
-    !isNonEmptyString(r.credential)
+    typeof r.credential !== 'string' ||
+    !SEAT_BEARER_RE.test(r.credential)
   ) {
     return false;
   }
@@ -204,7 +207,7 @@ function parseStore(raw: string): SeatsFile | null {
             !Array.isArray(replacement) &&
             Object.keys(replacement).length === 1 &&
             typeof (replacement as { credential?: unknown }).credential === 'string' &&
-            /^[A-Za-z0-9_-]{43}$/.test((replacement as { credential: string }).credential);
+            SEAT_BEARER_RE.test((replacement as { credential: string }).credential);
           let canonicalOrigin = false;
           try {
             const origin = new URL(String(withoutReplacement.origin));
@@ -338,6 +341,7 @@ export async function mintPendingSeat(input: {
     };
     txn.data.seats[ref] = record;
     await txn.commit();
+    rejectedSeatRefs.delete(ref);
     return record;
   });
 }
@@ -430,6 +434,7 @@ export async function prepareSeat(input: {
     };
     txn.data.seats[ref] = record;
     await txn.commit();
+    rejectedSeatRefs.delete(ref);
     return { ok: true as const, record };
   });
 }
@@ -498,6 +503,7 @@ export async function activateAndBindSeat(input: {
       ...(input.isHumanSeat !== undefined ? { isHumanSeat: input.isHumanSeat } : {}),
     };
     await txn.commit();
+    rejectedSeatRefs.delete(ref);
     return 'activated';
   });
 }
@@ -567,16 +573,28 @@ export async function bindPendingSeatToWorktree(input: {
 
 // ─── Hydration / enumeration (scan by worktree) ──────────────────────────────
 
-/** The exact ACTIVE seat bound to `worktree`, or null. A pending record (no
- *  worktree, or non-active) is NEVER surfaced as a live binding. */
+/** The preferred ACTIVE seat bound to `worktree`, or null. A pending record (no
+ *  worktree, or non-active) is NEVER surfaced as a live binding. Candidates use
+ *  one total order across every process: unrejected before rejected, a sibling
+ *  finalized into this worktree before an older in-place binding, then seat ref. */
 export async function getActiveSeatForWorktree(worktree: string): Promise<SeatRecord | null> {
   const store = await readStore();
-  for (const [ref, record] of Object.entries(store.seats)) {
-    if (record.state === 'active' && record.worktree === worktree && seatRef(record) === ref) {
-      return record;
-    }
-  }
-  return null;
+  const candidates = Object.entries(store.seats)
+    .filter(([ref, record]) =>
+      record.state === 'active' && record.worktree === worktree && seatRef(record) === ref)
+    .sort(([leftRef, left], [rightRef, right]) => {
+      const rejectionOrder = Number(rejectedSeatRefs.has(leftRef)) - Number(rejectedSeatRefs.has(rightRef));
+      if (rejectionOrder !== 0) return rejectionOrder;
+      const operationOrder = Number(left.operation.kind === 'seat') - Number(right.operation.kind === 'seat');
+      if (operationOrder !== 0) return operationOrder;
+      return leftRef < rightRef ? -1 : leftRef > rightRef ? 1 : 0;
+    });
+  return candidates[0]?.[1] ?? null;
+}
+
+/** Deprioritize an exact seat after a definitive server auth or eviction verdict. */
+export function markSeatRejected(ref: string): void {
+  if (REF_RE.test(ref)) rejectedSeatRefs.add(ref);
 }
 
 /**
@@ -624,6 +642,8 @@ export async function findIncompleteSiblingAttempt(binding: {
       record.state === 'pending' &&
       record.worktree === undefined &&
       record.operation.kind === 'sibling' &&
+      record.operation.operationKey.startsWith('implicit-sibling:') &&
+      record.operation.operationKey.length > 'implicit-sibling:'.length &&
       record.origin === binding.origin &&
       record.trustIdentity === binding.trustIdentity &&
       record.cubeId === binding.cubeId &&
@@ -696,6 +716,7 @@ export async function resetSeatForWorktree(expected: {
     }
     delete txn.data.seats[expected.ref];
     await txn.commit();
+    rejectedSeatRefs.delete(expected.ref);
     return { outcome: 'reset' as const, ref: expected.ref };
   });
 }
@@ -726,6 +747,7 @@ export async function clearSeat(ref: string): Promise<void> {
     if (txn.data.seats[ref] !== undefined) {
       delete txn.data.seats[ref];
       await txn.commit();
+      rejectedSeatRefs.delete(ref);
     }
   });
 }

package/src/update-cmd.ts

@@ -154,8 +154,8 @@ function isExactSemver(value: string): boolean {
   return EXACT_SEMVER.test(value);
 }
 
-function isCanonicalSha512Integrity(value: string): boolean {
-  if (!value.startsWith('sha512-') || value.includes(' ')) return false;
+function isCanonicalSha512Integrity(value: unknown): boolean {
+  if (typeof value !== 'string' || !value.startsWith('sha512-') || value.includes(' ')) return false;
   const encoded = value.slice('sha512-'.length);
   try {
     const bytes = Buffer.from(encoded, 'base64');
@@ -242,7 +242,7 @@ function validatePublishedPackage(
   expectedName: typeof CLIENT_PACKAGE | typeof SERVER_PACKAGE,
 ): void {
   if (value.name !== expectedName || !isExactSemver(value.version)) {
-    throw new Error(`registry returned an invalid ${expectedName} manifest identity`);
+    throw new Error(`registry returned an invalid ${expectedName} manifest identity (missing or invalid name/version field)`);
   }
   if (!isCanonicalSha512Integrity(value.integrity)) {
     throw new Error(`registry returned invalid ${expectedName} SHA-512 integrity`);
@@ -308,23 +308,6 @@ function decodeServerStatus(value: unknown): ServerStatus {
     throw new Error('server returned invalid JSON status');
   }
   const record = value as Record<string, unknown>;
-  const allowed = new Set([
-    'status',
-    'installed_controller',
-    'prepared_runtime',
-    'prepared_integrity',
-    'running_runtime',
-    'running_integrity',
-    'build_identity',
-    'endpoint',
-    'mode',
-    'service_adapter',
-    'data_identity',
-    'next_action',
-  ]);
-  for (const key of Object.keys(record)) {
-    if (!allowed.has(key)) throw new Error(`server status contains unknown field ${key}`);
-  }
   if (
     (record.status !== 'running' && record.status !== 'stopped') ||
     typeof record.installed_controller !== 'string' ||
@@ -382,10 +365,7 @@ function decodeServerUpdate(value: unknown): ServerUpdateResult {
   }
   const record = value as Record<string, unknown>;
   if (record.status === 'failed') {
-    const failureKeys = Object.keys(record);
     if (
-      failureKeys.length !== 4 ||
-      !failureKeys.every((key) => ['status', 'error_code', 'recovery', 'data_identity'].includes(key)) ||
       (record.error_code !== 'ARTIFACT_VERIFICATION_FAILED' && record.error_code !== 'ACTIVATION_FAILED') ||
       !['verification_failed', 'restored', 'stopped', 'recovery_failed'].includes(record.recovery as string) ||
       record.data_identity !== 'preserved' ||
@@ -400,20 +380,6 @@ function decodeServerUpdate(value: unknown): ServerUpdateResult {
       recovery: record.recovery as ServerUpdateFailure['recovery'],
     };
   }
-  const allowed = new Set([
-    'status',
-    'installed_controller',
-    'artifact',
-    'artifact_integrity',
-    'running_runtime',
-    'build_identity',
-    'mode',
-    'data_identity',
-    'next_action',
-  ]);
-  for (const key of Object.keys(record)) {
-    if (!allowed.has(key)) throw new Error(`server update contains unknown field ${key}`);
-  }
   if (
     (record.status !== 'prepared' && record.status !== 'updated') ||
     typeof record.installed_controller !== 'string' ||
@@ -505,11 +471,12 @@ export async function runUpdate(options: UpdateOptions, deps: UpdateDeps): Promi
       : (
         `${errorMessage(error, 'Update preflight failed')}\n` +
         `Observed update state:\n` +
-        `  client: unavailable (preflight incomplete)\n` +
-        `  server controller: unavailable (preflight incomplete)\n` +
+        `  client: not inspected (registry preflight incomplete)\n` +
+        `  server controller: not inspected (registry preflight incomplete)\n` +
         `  prepared runtime: not inspected\n` +
         `  running runtime: not inspected\n` +
-        `No mutation was attempted.\n`
+        `No mutation was attempted.\n` +
+        `Manual fallback: npm install -g ${CLIENT_PACKAGE} && npm install -g ${SERVER_PACKAGE}\n`
       ));
     return interrupted ?? 1;
   }
@@ -922,24 +889,35 @@ async function defaultPublishedPackage(
   context: NpmContext,
 ): Promise<PublishedPackage> {
   if (version !== 'latest' && !isExactSemver(version)) throw new Error('invalid registry target version');
-  const result = await runCommand(context.commandPath, [
-    'view',
-    `${name}@${version}`,
-    'name',
-    'version',
-    'dist.integrity',
-    `dependencies.${SHARED_PACKAGE}`,
-    `--registry=${CANONICAL_NPM_REGISTRY}`,
-    '--json',
-  ]);
-  if (result.code !== 0) throw new Error(`registry lookup failed for ${name}@${version}`);
-  const manifest = JSON.parse(result.stdout) as Record<string, unknown>;
-  return {
-    name: manifest.name as PublishedPackage['name'],
-    version: manifest.version as string,
-    integrity: manifest['dist.integrity'] as string,
-    sharedVersion: manifest[`dependencies.${SHARED_PACKAGE}`] as string,
-  };
+  // Keep npm context validation above, but read the registry's typed manifest
+  // contract directly rather than parsing npm CLI presentation output.
+  void context;
+  const endpoint = new URL(`${encodeURIComponent(name)}/${encodeURIComponent(version)}`, CANONICAL_NPM_REGISTRY);
+  let published: PublishedPackage;
+  try {
+    const response = await fetch(endpoint, {
+      headers: { Accept: 'application/json' },
+      redirect: 'error',
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const parsed: unknown = await response.json();
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('response was not a manifest object');
+    }
+    const manifest = parsed as Record<string, unknown>;
+    const dist = manifest.dist as Record<string, unknown> | undefined;
+    const dependencies = manifest.dependencies as Record<string, unknown> | undefined;
+    published = {
+      name: manifest.name as PublishedPackage['name'],
+      version: manifest.version as string,
+      integrity: dist?.integrity as string,
+      sharedVersion: dependencies?.[SHARED_PACKAGE] as string,
+    };
+  } catch {
+    throw new Error(`registry manifest lookup failed for ${name}@${version}`);
+  }
+  validatePublishedPackage(published, name);
+  return published;
 }
 
 async function defaultConfirm(message: string): Promise<'yes' | 'no' | 'eof' | 'interrupted'> {