borgmcp 2.12.1 → 2.14.0

package/src/remote-client.ts

@@ -85,10 +85,27 @@ export const LOCAL_SERVER_RESPONSE_LIMIT_BYTES = 32 * 1024 * 1024;
 // bounded read throws → the 401 fails closed to non-destructive CREDENTIAL_REJECTED.
 const AUTH_ERROR_ENVELOPE_LIMIT_BYTES = 64 * 1024;
 const ROLE_SECTION_CONFLICT_CODE = 'ROLE_SECTION_CONFLICT';
+const CAPACITY_EXCEEDED_CODE = 'CAPACITY_EXCEEDED';
 export const LOCAL_SERVER_REQUEST_TIMEOUT_MS = 5_000;
 const LOCAL_SERVER_RESPONSE_LIMIT_MESSAGE =
   'Local Borg server response exceeded the response limit';
 
+function sanitizeServerMessage(message: string): string {
+  return message
+    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, '')
+    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, '')
+    .replace(/\\u(?:000[0-9a-f]|001[0-9a-f]|007f|008[0-9a-f]|009[0-9a-f])/gi, '');
+}
+
+export const SERVER_ADVISORY_MAX_CHARS = 512;
+
+export function sanitizeServerAdvisory(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const sanitized = sanitizeServerMessage(value).trim();
+  return sanitized.length > 0 ? sanitized.slice(0, SERVER_ADVISORY_MAX_CHARS) : undefined;
+}
+
 /**
  * Parse a `Retry-After` header (delta-seconds form, which the worker
  * emits — mcp-server.ts:382/583) into milliseconds. Returns null when
@@ -725,11 +742,11 @@ async function authedFetch(
   }
 
   if (!response.ok) {
-    // Do not copy a server response body into errors or debug output: a malicious or
-    // misconfigured server could reflect bearer/invitation material or inject
-    // terminal controls. Decode only the bounded protocol error code for typed
-    // branching; never surface the server-provided message or details.
+    // Decode only the bounded protocol error envelope. Its message is the
+    // server's operator-facing action guidance; details and unrecognized bodies
+    // remain excluded from the client error.
     let code: ErrorCode | undefined;
+    let serverMessage: string | undefined;
     let protocolMismatch = false;
     try {
       const body = await readBoundedResponseBody(
@@ -739,7 +756,11 @@ async function authedFetch(
       );
       const parsed = JSON.parse(body);
       try {
-        code = decodeProtocolErrorEnvelope(parsed).error.code;
+        const decoded = decodeProtocolErrorEnvelope(parsed);
+        code = decoded.error.code;
+        serverMessage = response.status === 404
+          ? undefined
+          : sanitizeServerMessage(decoded.error.message);
       } catch (error) {
         if (
           error instanceof ProtocolContractError &&
@@ -750,21 +771,25 @@ async function authedFetch(
         if (
           parsed !== null && typeof parsed === 'object' &&
           parsed.error !== null && typeof parsed.error === 'object' &&
-          parsed.error.code === ROLE_SECTION_CONFLICT_CODE
+          (parsed.error.code === ROLE_SECTION_CONFLICT_CODE
+            || parsed.error.code === CAPACITY_EXCEEDED_CODE)
         ) {
           // The shared protocol intentionally omits this server-local code. Re-validate the whole
           // envelope through the strict shared decoder with only the recognized
-          // code substituted; no server-provided diagnostic is ever surfaced.
-          decodeProtocolErrorEnvelope({
+          // code substituted. The original message remains in place so the
+          // shared decoder validates its length and diagnostic shape.
+          const decoded = decodeProtocolErrorEnvelope({
             ...parsed,
             error: {
               ...parsed.error,
               code: ErrorCode.INVALID_INPUT,
-              message: 'Role section conflict.',
               ...(Object.hasOwn(parsed.error, 'details') ? { details: 'Redacted.' } : {}),
             },
           });
-          code = ROLE_SECTION_CONFLICT_CODE as ErrorCode;
+          code = parsed.error.code as ErrorCode;
+          serverMessage = response.status === 404
+            ? undefined
+            : sanitizeServerMessage(decoded.error.message);
         }
       }
     } catch {
@@ -782,7 +807,9 @@ async function authedFetch(
     }
     throw new BorgServerHttpError(
       response.status,
-      `Borg server request failed (HTTP ${response.status})`,
+      serverMessage
+        ? `Borg server request failed (HTTP ${response.status}): ${serverMessage}`
+        : `Borg server request failed (HTTP ${response.status})`,
       code,
     );
   }
@@ -1302,7 +1329,7 @@ export async function updateCube(
   updates: { name?: string; cube_directive?: string; message_taxonomy?: MessageTaxonomy | null },
   activeOverride?: ActiveCube,
   connectionOverride?: RemoteConnection,
-): Promise<{ cube: any }> {
+): Promise<{ cube: any; advisory?: unknown }> {
   assertUuidShape(cubeId, 'cube_id');
   const active = activeOverride ?? await getActiveCube();
   if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');
@@ -1438,7 +1465,7 @@ export async function updateRole(
   targetCubeId?: string,
   activeOverride?: ActiveCube,
   connectionOverride?: RemoteConnection,
-): Promise<{ role: any }> {
+): Promise<{ role: any; advisory?: unknown }> {
   assertUuidShape(roleId, 'role_id');
   const active = activeOverride ?? await getActiveCube();
   if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');
@@ -1514,7 +1541,7 @@ export async function patchRoleSection(
   targetCubeId?: string,
   activeOverride?: ActiveCube,
   connectionOverride?: RemoteConnection,
-): Promise<{ role: any }> {
+): Promise<{ role: any; advisory?: unknown }> {
   assertUuidShape(roleId, 'role_id');
   const active = activeOverride ?? await getActiveCube();
   if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');

package/src/roster-render.ts

@@ -28,6 +28,8 @@ export interface RosterDrone {
   last_seen: string | Date;
   /** Only present when the request carried `since`. */
   seen_since?: boolean;
+  /** Additive server-side wake state; absent on pre-C3 servers. */
+  wake_state?: 'idle' | 'pending' | 'awake' | 'stale';
   /**
    * gh#370 — which AI agent is running this drone. Null for drones that
    * joined before the column existed or via a launcher path that didn't
@@ -215,7 +217,8 @@ export function renderRoster(inputs: RenderRosterInputs): string {
     const regenCountMarker =
       typeof d.regen_count === 'number' ? ` · \`regen-count:${d.regen_count}\`` : '';
     if (resolvedSince) {
-      // T2.1 awake/stale column. `seen_since === true` → drone called a
+      // T2.1 awake/stale column. When available, wake_state is the server's
+      // richer state; older servers fall back to seen_since. `seen_since === true` → drone called a
       // tool after the resolved timestamp; treat as awake. False or
       // missing → stale. Missing should not happen when the server
       // echoed a since, but defending against a shape mismatch is
@@ -229,10 +232,9 @@ export function renderRoster(inputs: RenderRosterInputs): string {
       // probe call — pure redundancy. The per-row `last seen X ago`
       // field carries the diagnostic detail for "how stale is this
       // particular drone."
-      const isAwake = d.seen_since === true;
-      const marker = isAwake ? '`awake`' : '`stale`';
+      const marker = d.wake_state ?? (d.seen_since === true ? 'awake' : 'stale');
       lines.push(
-        `- **${d.label}**${addr} (Role: ${roleName}) — last seen ${lastSeen} · ${marker}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}`
+        `- **${d.label}**${addr} (Role: ${roleName}) — last seen ${lastSeen} · \`${marker}\`${regenCountMarker}${wakePathMarker}${wakePathClassMarker}`
       );
     } else {
       lines.push(