borgmcp 2.0.8 → 2.0.10

package/src/roster-render.ts

@@ -16,6 +16,10 @@
  */
 
 import { formatDroneAddressToken } from 'borgmcp-shared/drone-address';
+import { escapeSyncDisplay } from './sync-roles-render.js';
+
+export const RUNTIME_METADATA_ADVISORY =
+  'Agent CLI, reported model, and working repository are advisory. They do not determine authority, role, health, activity, wake behavior, or routing.';
 
 export interface RosterDrone {
   id?: string;
@@ -47,6 +51,7 @@ export interface RosterDrone {
   /** Current cwd-derived repository identity, refreshed on regen. */
   working_repo_name?: string | null;
   working_repo_origin?: string | null;
+  runtime_metadata_reported?: boolean;
 }
 
 export interface RosterRole {
@@ -104,6 +109,54 @@ export function formatWorkingRepoLabel(drone: Pick<RosterDrone, 'working_repo_na
   return 'Working repo: not reported';
 }
 
+function metadataValue(
+  drone: RosterDrone,
+  value: string | null | undefined,
+): string {
+  if (drone.runtime_metadata_reported !== true) return 'not reported';
+  return value == null ? 'unknown' : escapeRuntimeMetadataDisplay(value);
+}
+
+/**
+ * Keep accepted advisory metadata readable without letting a Markdown renderer
+ * or link-detecting terminal turn cube-controlled text into a live target.
+ * The visible `[.]` / `[:]` markers preserve the reported value's differences.
+ */
+export function escapeRuntimeMetadataDisplay(value: string): string {
+  const escaped = escapeSyncDisplay(value);
+  const defangedScheme = escaped.replace(
+    /\b([A-Za-z][A-Za-z0-9+.-]*)\:\/\//g,
+    '$1\\[:]//',
+  );
+  return defangedScheme.replace(
+    /\b(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,63}\b/g,
+    (host) => host.replaceAll('.', '\\[.\\]'),
+  );
+}
+
+export function renderRuntimeMetadataLines(
+  drone: RosterDrone,
+  opts: { includeOrigin?: boolean } = {},
+): string[] {
+  const agent = drone.agent_kind === 'claude'
+    ? 'Claude Code'
+    : drone.agent_kind === 'codex'
+      ? 'Codex'
+      : drone.agent_kind === 'opencode'
+        ? 'OpenCode'
+        : null;
+  const lines = [
+    `  - **Agent CLI:** ${metadataValue(drone, agent)}`,
+    `  - **Reported model:** ${metadataValue(drone, drone.reported_model)}`,
+    `  - **Working repo:** ${metadataValue(drone, drone.working_repo_name)}`,
+  ];
+  if (opts.includeOrigin) {
+    const origin = drone.working_repo_origin?.replace(/^https:\/\//i, '');
+    lines.push(`  - **Origin:** ${metadataValue(drone, origin)}`);
+  }
+  return lines;
+}
+
 export interface RenderRosterInputs {
   cubeName: string;
   drones: RosterDrone[];
@@ -126,6 +179,8 @@ export function renderRoster(inputs: RenderRosterInputs): string {
   const lines: string[] = [];
   lines.push(`# Drones in cube: ${cubeName}`);
   lines.push('');
+  lines.push(`_${RUNTIME_METADATA_ADVISORY}_`);
+  lines.push('');
 
   if (resolvedSince) {
     // Surface the liveness-probe context so the reader knows what the
@@ -146,15 +201,9 @@ export function renderRoster(inputs: RenderRosterInputs): string {
   for (const d of drones) {
     const role = roleById.get(d.role_id);
     const roleName = role?.name ?? 'unknown';
-    const roleLabel = formatRoleAgentLabel(roleName, d.agent_kind);
     // gh#371: stable short-uuid address token beside the (renumber-prone) label.
     const addr = d.id ? ` ${formatDroneAddressToken(d.id)}` : '';
     const lastSeen = humanAgo(d.last_seen);
-    const reportedModelMarker = d.reported_model
-      ? ` · \`Reported model: ${d.reported_model}\``
-      : ' · `Reported model: not reported`';
-    const workingRepo = formatWorkingRepoLabel(d);
-    const workingRepoMarker = ` · \`${workingRepo}\``;
     const wakePathMarker =
       d.wake_path && d.wake_path !== 'live'
         ? ` · \`wake-path:${WAKE_PATH_DISPLAY[d.wake_path] ?? d.wake_path}\``
@@ -183,13 +232,14 @@ export function renderRoster(inputs: RenderRosterInputs): string {
       const isAwake = d.seen_since === true;
       const marker = isAwake ? '`awake`' : '`stale`';
       lines.push(
-        `- **${d.label}**${addr} (${roleLabel}) — last seen ${lastSeen} · ${marker}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}${reportedModelMarker}${workingRepoMarker}`
+        `- **${d.label}**${addr} (Role: ${roleName}) — last seen ${lastSeen} · ${marker}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}`
       );
     } else {
       lines.push(
-        `- **${d.label}**${addr} (${roleLabel}) — last seen ${lastSeen}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}${reportedModelMarker}${workingRepoMarker}`
+        `- **${d.label}**${addr} (Role: ${roleName}) — last seen ${lastSeen}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}`
       );
     }
+    lines.push(...renderRuntimeMetadataLines(d, { includeOrigin: true }));
   }
 
   return lines.join('\n');

package/src/runtime-metadata.ts

@@ -0,0 +1,67 @@
+import type {
+  AgentKind,
+  DroneRuntimeMetadata,
+  DroneRuntimeMetadataPatch,
+} from 'borgmcp-shared/protocol';
+import {
+  canonicalizeRepositoryIdentity,
+  validateReportedModel,
+  validateRuntimeMetadata,
+  validateRuntimeMetadataPatch,
+} from 'borgmcp-shared/runtime-metadata';
+import type { WorkingRepo } from './working-repo.js';
+
+function safeReportedModel(value: string | null | undefined): string | null {
+  if (value == null) return null;
+  try {
+    return validateReportedModel(value);
+  } catch {
+    return null;
+  }
+}
+
+function reportableRepository(repo: WorkingRepo | undefined) {
+  if (!repo || repo.state === 'unavailable' || repo.state === 'rejected') return null;
+  if (repo.name === null && repo.origin === null) {
+    return { working_repo_name: null, working_repo_origin: null };
+  }
+  if (repo.name === null || repo.origin === null) return null;
+  try {
+    const canonical = canonicalizeRepositoryIdentity(repo.origin, repo.name);
+    return {
+      working_repo_name: canonical.working_repo_name,
+      working_repo_origin: canonical.working_repo_origin,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function buildRuntimeMetadataReport(input: {
+  agentKind: AgentKind | null | undefined;
+  reportedModel?: string | null;
+  workingRepo?: WorkingRepo;
+}): DroneRuntimeMetadata {
+  const repository = reportableRepository(input.workingRepo);
+  return validateRuntimeMetadata({
+    agent_kind: input.agentKind ?? null,
+    reported_model: safeReportedModel(input.reportedModel),
+    working_repo_name: repository?.working_repo_name ?? null,
+    working_repo_origin: repository?.working_repo_origin ?? null,
+  });
+}
+
+export function buildRuntimeMetadataPatch(input: {
+  agentKind: AgentKind | null;
+  reportedModel?: string;
+  workingRepo?: WorkingRepo;
+}): DroneRuntimeMetadataPatch {
+  const patch: DroneRuntimeMetadataPatch = { agent_kind: input.agentKind };
+  if (input.reportedModel !== undefined) {
+    const model = safeReportedModel(input.reportedModel);
+    if (model !== null) patch.reported_model = model;
+  }
+  const repository = reportableRepository(input.workingRepo);
+  if (repository) Object.assign(patch, repository);
+  return validateRuntimeMetadataPatch(patch);
+}

package/src/server-handshake.ts

@@ -15,6 +15,7 @@ import {
   decodeProtocolTagPreflight,
   ErrorCode,
   type CreateCubeResponse,
+  type DroneRuntimeMetadata,
   type ProtocolTagPreflight,
   type ServerCapability,
 } from 'borgmcp-shared/protocol';
@@ -235,6 +236,7 @@ export async function sendBorgServerAttach(
     roleId: string;
     operation: ServerSessionOperation;
     priorDroneId?: string;
+    runtimeMetadata?: DroneRuntimeMetadata;
   },
   pendingBearer: string,
   deps: {
@@ -274,9 +276,12 @@ export async function sendBorgServerAttach(
           cube_id: request.cubeId,
           role_id: request.roleId,
           session_credential: pending.credential,
-          ...(request.priorDroneId === undefined
+           ...(request.priorDroneId === undefined
+             ? {}
+             : { prior_drone_id: request.priorDroneId }),
+          ...(request.runtimeMetadata === undefined
             ? {}
-            : { prior_drone_id: request.priorDroneId }),
+            : { runtime_metadata: request.runtimeMetadata }),
         })),
       });
     } catch (error) {

package/src/sync-roles-render.ts

@@ -12,6 +12,8 @@
 
 export type FragmentKind = 'add' | 'unchanged' | 'conflict';
 
+const BIDI_CONTROL_RE = /\p{Bidi_Control}/u;
+
 export interface FragmentView {
   key: string;
   kind: FragmentKind;
@@ -35,10 +37,25 @@ export interface NonClobberSyncResult {
   unmatchedDecisions?: string[];
 }
 
+/** Escape cube-controlled text before it reaches Markdown or a terminal. */
+export function escapeSyncDisplay(value: string): string {
+  return [...value].map((char) => {
+    const code = char.codePointAt(0)!;
+    if (code === 0x0a) return '⏎';
+    if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) return `\\u{${code.toString(16)}}`;
+    if (BIDI_CONTROL_RE.test(char) || code === 0x2028 || code === 0x2029) {
+      return `\\u{${code.toString(16)}}`;
+    }
+    if (char === '`') return '\\u{60}';
+    if ('\\*_[]()<>&#|~'.includes(char)) return `\\${char}`;
+    return char;
+  }).join('');
+}
+
 /** Truncate long fragment bodies for at-a-glance diffs. */
 function trunc(s: string | null, n = 200): string {
   if (s == null) return '(absent)';
-  const flat = s.replace(/\n/g, '⏎');
+  const flat = escapeSyncDisplay(s);
   return flat.length > n ? flat.slice(0, n) + '…' : flat;
 }
 
@@ -75,7 +92,7 @@ export function renderSyncRolesResult(
   const mode = result.dryRun
     ? '**DRY RUN** (review conflicts below; re-run with `apply: true` + a `decisions` map to commit)'
     : '**APPLIED**';
-  const lines: string[] = [`## borg_sync-roles — ${mode}`, `Template: ${templateName}`, ''];
+  const lines: string[] = [`## borg_sync-roles — ${mode}`, `Template: ${escapeSyncDisplay(templateName)}`, ''];
 
   // Gather all fragments across roles + taxonomy for tallying.
   const allFragments: FragmentView[] = [
@@ -109,7 +126,7 @@ export function renderSyncRolesResult(
         : applied
           ? '✓ accepted — template version applied'
           : '↩ kept your version';
-      lines.push(`- **${f.label}** \`${f.key}\` ${status}`);
+       lines.push(`- **${escapeSyncDisplay(f.label)}** \`${escapeSyncDisplay(f.key)}\` ${status}`);
       lines.push(`  - cube (current): "${trunc(f.cubeValue)}"`);
       lines.push(`  - template (new): "${trunc(f.templateValue)}"`);
     }
@@ -127,7 +144,7 @@ export function renderSyncRolesResult(
         '(typo or stale key) — their intended accept had NO effect. Check the exact keys against the conflicts above:'
     );
     for (const k of unmatched) {
-      lines.push(`- \`${k}\``);
+       lines.push(`- \`${escapeSyncDisplay(k)}\``);
     }
     lines.push('');
   }
@@ -137,11 +154,11 @@ export function renderSyncRolesResult(
     lines.push(`### Additions (safe — auto-applied, zero clobber risk)`);
     for (const r of newRoles) {
       const note = result.dryRun ? '(new role — would be created)' : '✓ created';
-      lines.push(`- new role **${r.name}** ${note}`);
+       lines.push(`- new role **${escapeSyncDisplay(r.name)}** ${note}`);
     }
     for (const f of adds) {
       const note = result.dryRun ? '(would be added)' : '✓ added';
-      lines.push(`- **${f.label}** \`${f.key}\` ${note}`);
+       lines.push(`- **${escapeSyncDisplay(f.label)}** \`${escapeSyncDisplay(f.key)}\` ${note}`);
     }
     lines.push('');
   }
@@ -149,7 +166,7 @@ export function renderSyncRolesResult(
   // ── Custom roles (never touched) ──
   if (customRoles.length > 0) {
     lines.push(
-      `### Custom roles (untouched): ${customRoles.map((r) => r.name).join(', ')}`
+       `### Custom roles (untouched): ${customRoles.map((r) => escapeSyncDisplay(r.name)).join(', ')}`
     );
     lines.push('');
   }

package/src/working-repo.ts

@@ -7,10 +7,12 @@
  */
 
 import { spawnSync } from 'node:child_process';
+import { canonicalizeRepositoryIdentity } from 'borgmcp-shared/runtime-metadata';
 export interface WorkingRepo {
   name: string | null;
-  /** Canonical host/path identity, never a raw Git remote URL. */
+  /** Canonical public HTTPS identity, never a raw Git remote URL. */
   origin: string | null;
+  state?: 'known' | 'unknown' | 'unavailable' | 'rejected';
 }
 
 export interface WorkingRepoDeps {
@@ -30,43 +32,19 @@ function trimmed(value: string | null | undefined): string | null {
   return normalized ? normalized : null;
 }
 
-function nameFromIdentity(identity: string): string | null {
-  const lastPathSegment = identity.replace(/\/$/, '').split('/').pop();
-  const name = lastPathSegment?.replace(/\.git$/i, '').trim();
-  return name || null;
-}
-
 /**
- * Convert a Git remote to a non-secret `host/org/repo` identity.
- *
- * URL userinfo, query strings, fragments, scheme, and SCP-style user prefixes
- * are deliberately discarded. Inputs that cannot identify a host and path are
- * treated as unreportable rather than forwarded verbatim.
+ * Convert a Git remote to the shared canonical public repository identity.
+ * Hostile or credential-bearing inputs are rejected rather than sanitized.
  */
-export function canonicalizeWorkingRepoIdentity(origin: string): string | null {
-  const raw = origin.trim();
-  if (!raw) return null;
-  // Remote clients send this canonical form on subsequent lifecycle calls.
-  const canonical = raw.match(/^([A-Za-z0-9.-]+)\/([^?#\s]+)$/);
-  if (canonical) {
-    const host = canonical[1].toLowerCase();
-    const path = canonical[2].replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
-    return host && path ? `${host}/${path}` : null;
-  }
+export function canonicalizeWorkingRepoIdentity(origin: string): WorkingRepo | null {
   try {
-    const url = new URL(origin);
-    if (!['http:', 'https:', 'ssh:', 'git:'].includes(url.protocol)) return null;
-    const path = url.pathname.replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
-    return url.hostname && path ? `${url.hostname.toLowerCase()}/${path}` : null;
+    const canonical = canonicalizeRepositoryIdentity(origin.trim());
+    return {
+      name: canonical.working_repo_name,
+      origin: canonical.working_repo_origin,
+      state: 'known',
+    };
   } catch {
-    // SCP-style SSH remote: discard its optional user prefix and URL-like
-    // query/fragment suffix before accepting only host + repository path.
-    const match = raw.match(/^(?:[^@\s/:]+@)?([A-Za-z0-9.-]+):\/?([^?#\s]+)(?:[?#].*)?$/);
-    if (match) {
-      const host = match[1].toLowerCase();
-      const path = match[2].replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
-      return host && path ? `${host}/${path}` : null;
-    }
     return null;
   }
 }
@@ -83,17 +61,28 @@ export function resolveWorkingRepo(
   deps: WorkingRepoDeps = {}
 ): WorkingRepo {
   const runGit = deps.runGit ?? defaultRunGit;
-  const rootResult = runGit(cwd, ['rev-parse', '--show-toplevel']);
+  let rootResult;
+  try {
+    rootResult = runGit(cwd, ['rev-parse', '--show-toplevel']);
+  } catch {
+    return { name: null, origin: null, state: 'unavailable' };
+  }
   const root = rootResult.status === 0 ? trimmed(rootResult.stdout) : null;
   if (!root) {
-    return { name: null, origin: null };
+    return { name: null, origin: null, state: 'unknown' };
   }
 
-  const originResult = runGit(cwd, ['config', '--get', 'remote.origin.url']);
+  let originResult;
+  try {
+    originResult = runGit(cwd, ['config', '--get', 'remote.origin.url']);
+  } catch {
+    return { name: null, origin: null, state: 'unavailable' };
+  }
   const originRaw = originResult.status === 0 ? trimmed(originResult.stdout) : null;
-  const origin = originRaw ? canonicalizeWorkingRepoIdentity(originRaw) : null;
-  return {
-    name: origin ? nameFromIdentity(origin) : null,
-    origin,
+  if (!originRaw) return { name: null, origin: null, state: 'unknown' };
+  return canonicalizeWorkingRepoIdentity(originRaw) ?? {
+    name: null,
+    origin: null,
+    state: 'rejected',
   };
 }