borgmcp 2.0.9 → 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/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',
   };
 }