borgmcp 2.0.8 → 2.0.10

package/dist/remote-client.js

@@ -11,10 +11,13 @@
  */
 import { getServerCredential, } from './config.js';
 import { randomUUID } from 'node:crypto';
-import { createProtocolEnvelope, decodeEvictDroneResult, decodeProtocolEnvelope, decodeProtocolErrorEnvelope, decodeReassignDroneResult, ErrorCode, } from 'borgmcp-shared/protocol';
+import { createProtocolEnvelope, decodeDroneRuntimeMetadataState, decodeEvictDroneResult, decodeProtocolEnvelope, decodeProtocolErrorEnvelope, decodeReassignDroneResult, decodeUpdateDroneRuntimeMetadataResponse, ErrorCode, } from 'borgmcp-shared/protocol';
 import { debugLog } from './debug.js';
 import { assertUuidShape } from './evict-drone.js';
 import { DroneEvictedError, DRONE_EVICTED_CODE } from './drone-lifecycle.js';
+import { getTemplate } from 'borgmcp-shared/templates';
+import { parseRoleSections } from 'borgmcp-shared/role-section';
+import { buildRuntimeMetadataPatch } from './runtime-metadata.js';
 import { loadBorgServerTrust } from './server-trust.js';
 import { BorgServerError, BorgServerHttpError, BorgServerTrustError, BorgServerUnreachableError, LocalManageCredentialUnavailableError, LocalManageRequiredError, } from './server-errors.js';
 import { getActiveCube } from './cubes.js';
@@ -186,8 +189,11 @@ async function localManageConnection(active, operation) {
     }
     return { apiUrl: active.apiUrl, authToken, serverTrustIdentity: trustIdentity };
 }
-async function localManageRequest(active, path, method, operation, payload, decodePayload) {
-    const connection = await localManageConnection(active, operation);
+export async function resolveLocalManageAuthority(active, operation) {
+    return { active, connection: await localManageConnection(active, operation) };
+}
+async function localManageRequest(active, path, method, operation, payload, decodePayload, connectionOverride) {
+    const connection = connectionOverride ?? await localManageConnection(active, operation);
     try {
         return await decodeLocalProtocolResponse((signal) => authedFetch(path, {
             method,
@@ -224,6 +230,18 @@ async function localConnectionRequest(connection, path) {
         headers: { Accept: 'application/json' },
     }), false);
 }
+async function localConnectionMutation(connection, path, method, payload) {
+    return decodeLocalProtocolResponse((signal) => authedFetch(path, {
+        method,
+        signal,
+        apiUrl: connection.apiUrl,
+        authToken: connection.authToken,
+        serverTrustIdentity: connection.serverTrustIdentity,
+        redirect: 'error',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify(createProtocolEnvelope(randomUUID(), payload)),
+    }), false);
+}
 async function localOwnerConnection(connection) {
     if (connection)
         return connection;
@@ -250,18 +268,33 @@ async function localCubeComposition(active) {
     if (!cubePayload || !rolePayload || !dronePayload) {
         throw new Error('Local Borg server returned an incomplete cube response');
     }
-    const drone = dronePayload.drones.find((candidate) => candidate.id === active.droneId);
+    const drones = dronePayload.drones.map(withValidatedRuntimeMetadata);
+    const drone = drones.find((candidate) => candidate.id === active.droneId);
     const role = rolePayload.roles.find((candidate) => candidate.id === drone?.role_id);
     if (!drone || !role)
         throw new Error('Local Borg server no longer recognizes this drone seat');
     return {
         cube: cubePayload.cube,
         roles: rolePayload.roles,
-        drones: dronePayload.drones,
+        drones,
         role,
         drone,
     };
 }
+function withValidatedRuntimeMetadata(drone) {
+    const state = decodeDroneRuntimeMetadataState(drone);
+    return {
+        ...drone,
+        ...state.runtime_metadata,
+        runtime_metadata_reported: state.runtime_metadata_reported,
+    };
+}
+async function updateOwnRuntimeMetadata(active, patch) {
+    const payload = await localServerRequest(active, `/api/cubes/${active.cubeId}/drones/self/metadata`, 'PATCH', { ...patch });
+    if (!payload)
+        throw new Error('Local Borg server returned an empty runtime metadata response');
+    decodeUpdateDroneRuntimeMetadataResponse(payload);
+}
 function localCursorBinding(active) {
     return {
         origin: active.apiUrl,
@@ -503,6 +536,13 @@ export async function whoami(sessionToken, apiUrl, serverTrustIdentity) {
         drone_label: composed.drone.label,
         role_id: composed.role.id,
         role_name: composed.role.name,
+        runtime_metadata: {
+            agent_kind: composed.drone.agent_kind,
+            reported_model: composed.drone.reported_model,
+            working_repo_name: composed.drone.working_repo_name,
+            working_repo_origin: composed.drone.working_repo_origin,
+        },
+        runtime_metadata_reported: composed.drone.runtime_metadata_reported,
     };
 }
 /**
@@ -519,10 +559,28 @@ export async function whoami(sessionToken, apiUrl, serverTrustIdentity) {
  */
 export async function getRoster(sessionToken, apiUrl, since, serverTrustIdentity) {
     const local = await localAuthorityContext(sessionToken, apiUrl, serverTrustIdentity);
-    if (since !== undefined)
-        localUnsupported('roster liveness filtering');
+    if (since !== undefined) {
+        const [dronePayload, rolePayload, cubePayload] = await Promise.all([
+            localServerRequest(local, `/api/cubes/${local.cubeId}/drones?since=${encodeURIComponent(since)}`, 'GET'),
+            localServerRequest(local, `/api/cubes/${local.cubeId}/roles`, 'GET'),
+            localServerRequest(local, `/api/cubes/${local.cubeId}`, 'GET'),
+        ]);
+        if (!dronePayload || !rolePayload || !cubePayload) {
+            throw new Error('Local Borg server returned an incomplete roster response');
+        }
+        return {
+            drones: dronePayload.drones.map(withValidatedRuntimeMetadata),
+            roles: rolePayload.roles,
+            message_taxonomy: cubePayload.cube.message_taxonomy ?? null,
+            since: dronePayload.since ?? since,
+        };
+    }
     const composed = await localCubeComposition(local);
-    return { drones: composed.drones, roles: composed.roles, message_taxonomy: null };
+    return {
+        drones: composed.drones,
+        roles: composed.roles,
+        message_taxonomy: composed.cube.message_taxonomy ?? null,
+    };
 }
 /**
  * Read recent log entries for the cube.
@@ -612,6 +670,23 @@ export async function removeDecision(sessionToken, apiUrl, selector, serverTrust
  */
 export async function regen(sessionToken, apiUrl, opts = {}) {
     const local = await localAuthorityContext(sessionToken, apiUrl, opts.serverTrustIdentity);
+    if (opts.agentKind !== undefined ||
+        opts.reportedModel !== undefined ||
+        opts.workingRepo !== undefined) {
+        const patch = buildRuntimeMetadataPatch({
+            agentKind: opts.agentKind ?? null,
+            reportedModel: opts.reportedModel,
+            workingRepo: opts.workingRepo,
+        });
+        try {
+            await updateOwnRuntimeMetadata(local, patch);
+        }
+        catch {
+            // Metadata is advisory. Preserve the prior server value and continue with
+            // the authenticated identity read; never echo rejected local input.
+            console.warn('Local regen: runtime metadata update unavailable; preserving the prior safe report.');
+        }
+    }
     const composed = await localCubeComposition(local);
     const cursor = opts.since === undefined
         ? await getLocalServerCursor(localCursorBinding(local))
@@ -707,19 +782,32 @@ export async function listCubes(connection) {
  * Existing callers that read `body.cube` keep working (forward-compat).
  */
 export async function createCube(name, cubeDirective, opts, connection) {
-    void name;
-    void cubeDirective;
-    void opts;
-    void connection;
-    localUnsupported('cube creation');
+    if (!name?.trim())
+        throw new Error('Local Borg server cube creation requires a cube name');
+    if (opts?.template !== undefined && opts.template !== 'default') {
+        throw new Error('Local Borg server supports only the default cube seed');
+    }
+    const resolved = await localOwnerConnection(connection);
+    const created = await localConnectionMutation(resolved, '/api/cubes', 'POST', {
+        retry_key: randomUUID(),
+        name: name.trim(),
+        template: 'default',
+    });
+    if (!created?.cube_id)
+        throw new Error('Local Borg server returned an invalid cube creation response');
+    const patch = { cube_directive: cubeDirective };
+    if (opts?.message_taxonomy !== undefined)
+        patch.message_taxonomy = opts.message_taxonomy;
+    await localConnectionMutation(resolved, `/api/cubes/${created.cube_id}`, 'PATCH', patch);
+    return getCube(created.cube_id, resolved);
 }
 /**
  * Update a cube's name and/or cube_directive. Both fields are optional;
  * pass only what changes.
  */
-export async function updateCube(cubeId, updates) {
+export async function updateCube(cubeId, updates, activeOverride, connectionOverride) {
     assertUuidShape(cubeId, 'cube_id');
-    const active = await getActiveCube();
+    const active = activeOverride ?? await getActiveCube();
     if (!active?.serverTrustIdentity)
         throw new Error('Selected Borg server authority state is missing or unreadable');
     if (updates.name !== undefined)
@@ -734,7 +822,7 @@ export async function updateCube(cubeId, updates) {
         operation: `update cube settings in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
         cubeName: cubeId === active.cubeId ? active.name : cubeId,
         noMutation: 'No cube settings were changed.',
-    }, payload);
+    }, payload, undefined, connectionOverride);
     if (!result)
         throw new Error('Local Borg server returned an empty cube response');
     return result;
@@ -745,9 +833,9 @@ export async function updateCube(cubeId, updates) {
  * other classes unchanged. The server re-validates the full resulting
  * array and requires the selected local client's live cube-manage grant.
  */
-export async function patchTaxonomyClass(cubeId, op) {
+export async function patchTaxonomyClass(cubeId, op, activeOverride, connectionOverride) {
     assertUuidShape(cubeId, 'cube_id');
-    const active = await getActiveCube();
+    const active = activeOverride ?? await getActiveCube();
     if (!active?.serverTrustIdentity)
         throw new Error('Selected Borg server authority state is missing or unreadable');
     const className = op.action === 'remove' ? op.class : op.class_def.class;
@@ -758,7 +846,7 @@ export async function patchTaxonomyClass(cubeId, op) {
         operation: `${op.action} message class ${manageCopyValue(className)} ${preposition} cube ${manageCopyValue(cubeName)}`,
         cubeName,
         noMutation: `No message class was ${pastTense}.`,
-    }, op);
+    }, op, undefined, connectionOverride);
     if (!result)
         throw new Error('Local Borg server returned an empty taxonomy response');
     return result;
@@ -775,9 +863,9 @@ export async function deleteCube(cubeId) {
  * Create a role inside a cube. is_default=true demotes the previous
  * default role; the cube always has exactly one default.
  */
-export async function createRole(cubeId, data) {
+export async function createRole(cubeId, data, activeOverride, connectionOverride) {
     assertUuidShape(cubeId, 'cube_id');
-    const active = await getActiveCube();
+    const active = activeOverride ?? await getActiveCube();
     if (!active?.serverTrustIdentity)
         throw new Error('Selected Borg server authority state is missing or unreadable');
     if (data.default_model !== undefined)
@@ -786,7 +874,7 @@ export async function createRole(cubeId, data) {
         operation: `create role ${manageCopyValue(data.name)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
         cubeName: cubeId === active.cubeId ? active.name : cubeId,
         noMutation: 'No role was created.',
-    }, buildLocalRoleFields(data));
+    }, buildLocalRoleFields(data), undefined, connectionOverride);
     if (!result)
         throw new Error('Local Borg server returned an empty role response');
     return result;
@@ -794,19 +882,20 @@ export async function createRole(cubeId, data) {
 /**
  * Update a role. All fields optional; pass only what changes.
  */
-export async function updateRole(roleId, updates) {
+export async function updateRole(roleId, updates, targetCubeId, activeOverride, connectionOverride) {
     assertUuidShape(roleId, 'role_id');
-    const active = await getActiveCube();
+    const active = activeOverride ?? await getActiveCube();
     if (!active?.serverTrustIdentity)
         throw new Error('Selected Borg server authority state is missing or unreadable');
-    assertUuidShape(active.cubeId, 'cube_id');
+    const cubeId = targetCubeId ?? active.cubeId;
+    assertUuidShape(cubeId, 'cube_id');
     if (updates.default_model !== undefined)
         localUnsupported('per-role default model');
-    const result = await localManageRequest(active, `/api/cubes/${active.cubeId}/roles/${roleId}`, 'PATCH', {
-        operation: `update role ${manageCopyValue(roleId)} in cube ${manageCopyValue(active.name)}`,
-        cubeName: active.name,
+    const result = await localManageRequest(active, `/api/cubes/${cubeId}/roles/${roleId}`, 'PATCH', {
+        operation: `update role ${manageCopyValue(roleId)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
         noMutation: 'No role was updated.',
-    }, buildLocalRoleFields(updates));
+    }, buildLocalRoleFields(updates), undefined, connectionOverride);
     if (!result)
         throw new Error('Local Borg server returned an empty role response');
     return result;
@@ -842,17 +931,18 @@ function buildLocalRoleFields(fields) {
  * client's live cube-manage grant. Sections are delimited by plain-label lines (e.g.
  * `Workflow:`), NOT markdown headings.
  */
-export async function patchRoleSection(roleId, op) {
+export async function patchRoleSection(roleId, op, targetCubeId, activeOverride, connectionOverride) {
     assertUuidShape(roleId, 'role_id');
-    const active = await getActiveCube();
+    const active = activeOverride ?? 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(active, `/api/cubes/${active.cubeId}/roles/${roleId}/section-patch`, 'POST', {
-        operation: `${op.action} section ${manageCopyValue(op.heading)} ${op.action === 'delete' ? 'from' : 'in'} role ${manageCopyValue(roleId)} in cube ${manageCopyValue(active.name)}`,
-        cubeName: active.name,
+    const cubeId = targetCubeId ?? active.cubeId;
+    assertUuidShape(cubeId, 'cube_id');
+    const result = await localManageRequest(active, `/api/cubes/${cubeId}/roles/${roleId}/section-patch`, 'POST', {
+        operation: `${op.action} section ${manageCopyValue(op.heading)} ${op.action === 'delete' ? 'from' : 'in'} role ${manageCopyValue(roleId)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
         noMutation: `No role section was ${op.action === 'insert' ? 'inserted' : op.action === 'replace' ? 'replaced' : 'deleted'}.`,
-    }, { ...op });
+    }, { ...op }, undefined, connectionOverride);
     if (!result)
         throw new Error('Local Borg server returned an empty role response');
     return result;
@@ -920,12 +1010,12 @@ export async function listRoles(cubeId) {
     }
     return result.roles;
 }
-export async function getCubeForManagement(cubeId, operation, activeOverride) {
+export async function getCubeForManagement(cubeId, operation, activeOverride, connectionOverride) {
     assertUuidShape(cubeId, 'cube_id');
     const active = activeOverride ?? await getActiveCube();
     if (!active?.serverTrustIdentity)
         throw new Error('Selected Borg server authority state is missing or unreadable');
-    return getCube(cubeId, await localManageConnection(active, operation));
+    return getCube(cubeId, connectionOverride ?? await localManageConnection(active, operation));
 }
 /**
  * Fetch a cube's full detail: directive, roles (with detailed
@@ -944,7 +1034,7 @@ export async function getCube(cubeId, connection) {
     return {
         ...cubePayload.cube,
         roles: rolePayload.roles,
-        drones: dronePayload.drones,
+        drones: dronePayload.drones.map(withValidatedRuntimeMetadata),
     };
 }
 /**
@@ -956,10 +1046,45 @@ export async function getCube(cubeId, connection) {
  * `{ created, updated }` counts. To selectively take template versions of
  * conflicting fragments, use `syncRoles` with a `decisions` map instead.
  */
-export async function applyTemplate(cubeId, templateName) {
-    void cubeId;
-    void templateName;
-    localUnsupported('template application');
+export async function applyTemplate(cubeId, templateName, authorityOverride) {
+    assertUuidShape(cubeId, 'cube_id');
+    const template = getTemplate(templateName);
+    if (!template)
+        throw new Error(`Unknown Borg template ${JSON.stringify(templateName)}`);
+    const active = authorityOverride?.active ?? await getActiveCube();
+    if (!active?.serverTrustIdentity)
+        throw new Error('Selected Borg server authority state is missing or unreadable');
+    const authority = authorityOverride ?? await resolveLocalManageAuthority(active, {
+        operation: `apply template ${manageCopyValue(templateName)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
+        noMutation: 'No template fragments were changed.',
+    });
+    const current = await getCubeForManagement(cubeId, {
+        operation: `apply template ${manageCopyValue(templateName)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
+        noMutation: 'No template fragments were changed.',
+    }, active, authority.connection);
+    let created = 0;
+    let updated = 0;
+    for (const role of template.roles) {
+        const existing = current.roles.find((candidate) => candidate.name === role.name);
+        if (!existing) {
+            await createRole(cubeId, role, active, authority.connection);
+            created++;
+            continue;
+        }
+        if (await applyMissingRoleFields(existing, role, cubeId, active, authority.connection))
+            updated++;
+        updated += await applyMissingRoleSections(existing, role, cubeId, active, authority.connection);
+    }
+    for (const classDef of template.message_taxonomy ?? []) {
+        const currentClasses = (current.message_taxonomy ?? []);
+        if (!currentClasses.some((candidate) => candidate.class === classDef.class)) {
+            await patchTaxonomyClass(cubeId, { action: 'add', class_def: classDef }, active, authority.connection);
+            updated++;
+        }
+    }
+    return { created, updated };
 }
 /**
  * gh#473 PR2 — NON-CLOBBERING sync of a cube's roles + message_taxonomy
@@ -972,11 +1097,166 @@ export async function applyTemplate(cubeId, templateName) {
  * never silently overwritten. Custom roles (names not in template) are
  * never touched. Returns a NonClobberSyncResult.
  */
-export async function syncRoles(cubeId, templateName = 'software-dev', apply = false, decisions) {
-    void cubeId;
-    void templateName;
-    void apply;
-    void decisions;
-    localUnsupported('role synchronization');
+export async function syncRoles(cubeId, templateName = 'software-dev', apply = false, decisions, authorityOverride) {
+    assertUuidShape(cubeId, 'cube_id');
+    const template = getTemplate(templateName);
+    if (!template)
+        throw new Error(`Unknown Borg template ${JSON.stringify(templateName)}`);
+    const active = authorityOverride?.active ?? await getActiveCube();
+    if (!active?.serverTrustIdentity)
+        throw new Error('Selected Borg server authority state is missing or unreadable');
+    const authority = authorityOverride ?? await resolveLocalManageAuthority(active, {
+        operation: `sync template ${manageCopyValue(templateName)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
+        noMutation: 'No role synchronization changes were applied.',
+    });
+    const current = await getCubeForManagement(cubeId, {
+        operation: `sync template ${manageCopyValue(templateName)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
+        noMutation: 'No role synchronization changes were applied.',
+    }, active, authority.connection);
+    const roles = [];
+    const taxonomy = [];
+    const additions = [];
+    const conflictKeys = new Set();
+    for (const role of template.roles) {
+        const existing = current.roles.find((candidate) => candidate.name === role.name);
+        if (!existing) {
+            const key = `role:${role.name}`;
+            const fragments = [{
+                    key,
+                    kind: 'add',
+                    label: 'role',
+                    cubeValue: null,
+                    templateValue: role.name,
+                }];
+            roles.push({ name: role.name, status: 'new', fragments });
+            additions.push({ key, run: async () => { await createRole(cubeId, role, active, authority.connection); } });
+            continue;
+        }
+        const fragments = [];
+        addRoleScalarFragment(fragments, additions, conflictKeys, decisions, existing, role, 'short_description', 'short description', cubeId, active, authority.connection);
+        for (const field of ['is_default', 'is_mandatory', 'is_human_seat', 'can_broadcast', 'receives_all_direct']) {
+            if (role[field] !== undefined)
+                addRoleScalarFragment(fragments, additions, conflictKeys, decisions, existing, role, field, field, cubeId, active, authority.connection);
+        }
+        const currentSections = new Map(parseRoleSections(String(existing.detailed_description ?? '')).map((section) => [section.heading, section]));
+        for (const section of parseRoleSections(role.detailed_description)) {
+            if (!section.heading)
+                continue;
+            const key = `role:${role.name}:section:${section.heading}`;
+            const previous = currentSections.get(section.heading);
+            const kind = !previous ? 'add' : previous.body === section.body ? 'unchanged' : 'conflict';
+            fragments.push({ key, kind, label: `section ${section.heading}`, cubeValue: previous?.body ?? null, templateValue: section.body });
+            if (kind === 'add')
+                additions.push({ key, run: async () => { await patchRoleSection(existing.id, { action: 'insert', heading: section.heading, body: section.body }, cubeId, active, authority.connection); } });
+            if (kind === 'conflict')
+                conflictKeys.add(key);
+            if (kind === 'conflict' && decisions?.[key] === 'accept')
+                additions.push({ key, run: async () => { await patchRoleSection(existing.id, { action: 'replace', heading: section.heading, body: section.body }, cubeId, active, authority.connection); } });
+        }
+        roles.push({ name: role.name, status: 'existing', fragments });
+    }
+    for (const existing of current.roles) {
+        if (!template.roles.some((role) => role.name === existing.name)) {
+            roles.push({ name: existing.name, status: 'custom-skipped', fragments: [] });
+        }
+    }
+    for (const classDef of template.message_taxonomy ?? []) {
+        const key = `taxonomy:${classDef.class}`;
+        const currentClass = (current.message_taxonomy ?? []).find((candidate) => candidate.class === classDef.class);
+        const currentValue = currentClass ? stableJson(currentClass) : null;
+        const templateValue = stableJson(classDef);
+        const kind = !currentClass ? 'add' : currentValue === templateValue ? 'unchanged' : 'conflict';
+        taxonomy.push({ key, kind, label: `taxonomy class ${classDef.class}`, cubeValue: currentValue, templateValue });
+        if (kind === 'add')
+            additions.push({ key, run: async () => { await patchTaxonomyClass(cubeId, { action: 'add', class_def: classDef }, active, authority.connection); } });
+        if (kind === 'conflict')
+            conflictKeys.add(key);
+        if (kind === 'conflict' && decisions?.[key] === 'accept')
+            additions.push({ key, run: async () => { await patchTaxonomyClass(cubeId, { action: 'replace', class_def: classDef }, active, authority.connection); } });
+    }
+    const acceptedConflicts = [...conflictKeys].filter((key) => decisions?.[key] === 'accept');
+    const rejectedConflicts = [...conflictKeys].filter((key) => decisions?.[key] !== 'accept');
+    const classifiedKeys = new Set([...conflictKeys]);
+    const unmatchedDecisions = Object.keys(decisions ?? {}).filter((key) => !classifiedKeys.has(key));
+    const addedKeys = additions.filter(({ key }) => !conflictKeys.has(key)).map(({ key }) => key);
+    if (apply) {
+        for (const addition of additions) {
+            if (conflictKeys.has(addition.key) && decisions?.[addition.key] !== 'accept')
+                continue;
+            await addition.run();
+        }
+    }
+    return {
+        dryRun: !apply,
+        roles,
+        taxonomy,
+        applied: {
+            added: apply ? addedKeys : [],
+            acceptedConflicts: apply ? acceptedConflicts : [],
+        },
+        rejectedConflicts,
+        unmatchedDecisions,
+    };
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function addRoleScalarFragment(fragments, additions, conflictKeys, decisions, existing, template, field, label, cubeId, active, connection) {
+    const templateValue = template[field];
+    if (templateValue === undefined)
+        return;
+    const key = `role:${template.name}:${field}`;
+    const currentValue = existing[field];
+    const missing = currentValue === undefined || (field === 'short_description' && currentValue === '');
+    const kind = missing ? 'add' : currentValue === templateValue ? 'unchanged' : 'conflict';
+    fragments.push({ key, kind, label, cubeValue: missing ? null : String(currentValue), templateValue: String(templateValue) });
+    if (kind === 'add')
+        additions.push({
+            key,
+            run: async () => { await updateRole(existing.id, { [field]: templateValue }, cubeId, active, connection); },
+        });
+    if (kind === 'conflict') {
+        conflictKeys.add(key);
+        if (decisions?.[key] === 'accept')
+            additions.push({
+                key,
+                run: async () => { await updateRole(existing.id, { [field]: templateValue }, cubeId, active, connection); },
+            });
+    }
+}
+async function applyMissingRoleFields(existing, template, cubeId, active, connection) {
+    const updates = {};
+    if ((existing.short_description === undefined || existing.short_description === '') && template.short_description) {
+        updates.short_description = template.short_description;
+    }
+    for (const field of ['is_default', 'is_mandatory', 'is_human_seat', 'can_broadcast', 'receives_all_direct']) {
+        if (existing[field] === undefined && template[field] !== undefined)
+            updates[field] = template[field];
+    }
+    if (Object.keys(updates).length === 0)
+        return false;
+    await updateRole(existing.id, updates, cubeId, active, connection);
+    return true;
+}
+async function applyMissingRoleSections(existing, template, cubeId, active, connection) {
+    const currentSections = new Map(parseRoleSections(String(existing.detailed_description ?? '')).map((section) => [section.heading, section]));
+    let updated = 0;
+    for (const section of parseRoleSections(template.detailed_description)) {
+        if (section.heading && !currentSections.has(section.heading)) {
+            await patchRoleSection(existing.id, { action: 'insert', heading: section.heading, body: section.body }, cubeId, active, connection);
+            updated++;
+        }
+    }
+    return updated;
 }
 //# sourceMappingURL=remote-client.js.map