borgmcp 3.0.0 → 3.1.0

package/src/remote-client.ts

@@ -17,17 +17,23 @@ import { randomUUID } from 'node:crypto';
 import {
   createProtocolEnvelope,
   decodeDeleteCubeResponse,
+  decodeDeleteRoleRequest,
+  decodeDeleteRoleResult,
   decodeDroneRuntimeMetadataState,
   decodeEvictDroneResult,
   decodeProtocolEnvelope,
   decodeProtocolErrorEnvelope,
   decodeReassignDroneResult,
+  decodeRoleRationaleRequest,
+  decodeRoleRationaleResult,
   decodeUpdateDroneRuntimeMetadataResponse,
   ErrorCode,
   ProtocolContractError,
   type AgentKind,
+  type DeleteRoleResult,
   type EvictDroneResult,
   type ReassignDroneResult,
+  type RoleRationaleResult,
 } from 'borgmcp-shared/protocol';
 import { consolePrefix } from './console-prefix.js';
 import { debugLog } from './debug.js';
@@ -95,16 +101,22 @@ export const LOCAL_SERVER_REQUEST_TIMEOUT_MS = 5_000;
 const LOCAL_SERVER_RESPONSE_LIMIT_MESSAGE =
   'Local Borg server response exceeded the response limit';
 
+export const SERVER_ADVISORY_MAX_CHARS = 512;
+// Keep enough source headroom to remove control sequences that cross the
+// visible 512-character boundary without letting regex work scale with the
+// 32 MiB response-body limit.
+const SERVER_MESSAGE_SANITIZE_MAX_CHARS = SERVER_ADVISORY_MAX_CHARS * 8;
+
 function sanitizeServerMessage(message: string): string {
-  return message
-    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, '')
-    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+  const bounded = message.slice(0, SERVER_MESSAGE_SANITIZE_MAX_CHARS);
+
+  return bounded
+    .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();
@@ -295,7 +307,10 @@ async function localServerRequest<T>(
   path: string,
   method: 'GET' | 'POST' | 'PUT' | 'PATCH',
   payload?: Record<string, unknown>,
-  options: { retryMode?: AuthedFetchRetryMode } = {},
+  options: {
+    retryMode?: AuthedFetchRetryMode;
+    decodePayload?: (value: unknown) => T;
+  } = {},
 ): Promise<T | null> {
   return decodeLocalProtocolResponse<T>((signal) => authedFetch(path, {
       method,
@@ -312,7 +327,7 @@ async function localServerRequest<T>(
           body: JSON.stringify(createProtocolEnvelope(randomUUID(), payload)),
         }),
       retryMode: options.retryMode,
-    }), true);
+    }), true, options.decodePayload);
 }
 
 export interface LocalManageOperation {
@@ -1247,12 +1262,21 @@ export async function roleRationale(
   section: string,
   serverTrustIdentity?: string,
 ): Promise<{ role: string; section: string; body: string }> {
-  void sessionToken;
-  void apiUrl;
-  void role;
-  void section;
-  void serverTrustIdentity;
-  localUnsupported('role rationale sections');
+  const local = await localAuthorityContext(sessionToken, apiUrl, serverTrustIdentity);
+  const request = decodeRoleRationaleRequest({ role, section });
+  const result = await localServerRequest<RoleRationaleResult>(
+    local,
+    `/api/cubes/${local.cubeId}/role-rationale`,
+    'POST',
+    { ...request },
+    { decodePayload: decodeRoleRationaleResult },
+  );
+  if (!result) throw new Error('Local Borg server returned an empty role rationale response');
+  return {
+    role: result.role_name,
+    section: result.section.heading,
+    body: result.section.body,
+  };
 }
 
 /**
@@ -1656,8 +1680,26 @@ export async function patchRoleSection(
  * (reassign or evict those drones first).
  */
 export async function deleteRole(roleId: string): Promise<void> {
-  void roleId;
-  localUnsupported('role deletion');
+  assertUuidShape(roleId, 'role_id');
+  const active = await getActiveCube();
+  if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');
+  assertUuidShape(active.cubeId, 'cube_id');
+  const result = await localManageRequest<DeleteRoleResult>(
+    active,
+    `/api/cubes/${active.cubeId}/roles/${roleId}`,
+    'DELETE',
+    {
+      operation: `delete role ${manageCopyValue(roleId)} from cube ${manageCopyValue(active.name)}`,
+      cubeName: active.name,
+      noMutation: 'No role was deleted.',
+    },
+    decodeDeleteRoleRequest({}),
+    decodeDeleteRoleResult,
+  );
+  if (!result) throw new Error('Local Borg server returned an empty role deletion response');
+  if (result.role_id !== roleId) {
+    throw new Error('Local Borg server returned a deletion response for an unexpected role');
+  }
 }
 
 /**

package/src/server-handshake.ts

@@ -214,7 +214,7 @@ export interface ServerAttachResult {
 }
 
 /**
- * Attach an enrolled client principal to one granted cube/role over protocol v7.
+ * Attach an enrolled client principal to one granted cube/role over protocol v8.
  * The client CSPRNG-generates the session bearer and persists it PENDING in the
  * OS keychain (keyed by the stable per-seat identity) BEFORE this request, so an
  * interrupted/lost response is recovered by re-sending the exact same bearer —

package/src/tool-manifest.ts

@@ -154,8 +154,8 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
         {
           name: 'borg_role-rationale',
           description:
-            "Fetch an on-demand rationale/case-study section for a role playbook. " +
-            "Pass a role name/id and a plain-label section key to read the rationale without expanding every context refresh.",
+            "Fetch exactly one named section from a role's detailed playbook using the current drone session. " +
+            "Pass a role name/UUID and a plain-label section key. Role names and section keys match case-insensitively; UUIDs match exactly. Malformed selectors, ambiguous role names, and unknown roles/sections refuse. Returns the server's canonical role name, role_id, section heading, and the section body in full, refusing rather than truncating when it exceeds the server's role-text size limit, so a drone can read one section on demand instead of carrying the whole playbook in every borg_regen.",
           inputSchema: {
             type: 'object',
             properties: {
@@ -481,7 +481,7 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
         },
         {
           name: 'borg_delete-role',
-          description: 'Delete a role. Refuses if any drone is still assigned — reassign them with borg_reassign-drone or remove them with borg_evict-drone first.',
+          description: 'Delete a role using the selected local client\'s cube-management grant. Unknown or inaccessible roles refuse. Also refuses for the default, mandatory, or human-seat role; a role referenced by message-taxonomy routing; or a role assigned to an active drone. Reassign active drones with borg_reassign-drone or remove them with borg_evict-drone first. Evicted drones that held the deleted role are reassigned to the cube\'s default role; their activity-log attribution is unaffected.',
           inputSchema: {
             type: 'object',
             properties: {