borgmcp 2.0.9 → 2.0.11

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/tool-manifest.ts

@@ -551,7 +551,7 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
         {
           name: 'borg_apply-template',
           description:
-            'Apply a named template to an existing cube, NON-CLOBBERINGLY. Roles are merged by name: new roles are created; existing template-named roles get template sections/classes the cube LACKS auto-applied, but EVOLVED (conflicting) text is preserved, never overwritten. Use this to retrofit an existing cube with a richer role set (e.g. add Coordinator/Reviewer/UX Expert). To review + selectively accept conflicting fragments, use borg_sync-roles (which surfaces each conflict + takes per-fragment accept decisions).',
+            'A client-orchestrated, non-clobbering application of a named template through role and taxonomy primitives. Requires the selected local client\'s live cube-manage grant. Roles are merged by name: new roles are created; existing template-named roles get missing sections/classes applied, while conflicting text is preserved. Operations are sequential, not atomic: if a later primitive fails, earlier operations may already be committed. Use borg_sync-roles to review and selectively accept conflicts.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -564,7 +564,7 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
         {
           name: 'borg_sync-roles',
           description:
-            'Non-clobbering sync of a cube\'s roles + message_taxonomy against the built-in template. Dry-run (default) classifies each fragment (role-text section, short_description, role flags, taxonomy class) as ADD (cube lacks it — safe auto-apply), UNCHANGED, or CONFLICT (cube has EVOLVED text). On apply, ADDs auto-apply; CONFLICTs apply ONLY via an explicit `decisions` accept (keyed on the dry-run fragment key, e.g. `role:Builder:section:Workflow`); unspecified conflicts default to reject — evolved text is NEVER silently overwritten. Custom roles untouched.',
+            'A client-orchestrated, non-clobbering sync through role and taxonomy primitives. Requires the selected local client\'s live cube-manage grant. Dry-run (default) classifies each fragment as ADD, UNCHANGED, or CONFLICT. On apply, ADDs apply automatically; conflicts apply only through an explicit `decisions` accept, and unspecified conflicts remain unchanged. Operations are sequential, not atomic: if a later primitive fails, earlier operations may already be committed. Custom roles remain untouched.',
           inputSchema: {
             type: 'object',
             properties: {

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',
   };
 }