maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.4.20260830

package/dist/cli-core.js

@@ -435,6 +435,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 expectedTarget: command.expectedTarget,
                 ...(command.meshId !== undefined ? { meshId: command.meshId } : {}),
                 ...(command.peerId ? { peerId: command.peerId } : {}),
+                ...(command.displayName !== undefined ? { displayName: command.displayName } : {}),
             });
         }
         case 'runtime-host-service-update': {

package/dist/runtime-host-cli.js

@@ -752,17 +752,28 @@ function parseServicePeerMeshCommand(argv) {
         action !== 'leave' &&
         action !== 'close' &&
         action !== 'reconcile' &&
-        action !== 'transit') {
+        action !== 'transit' &&
+        action !== 'rename' &&
+        action !== 'rename-mesh') {
         return error(action
             ? `Unexpected runtime-host service mesh command: ${action}`
-            : 'runtime-host service mesh requires status, create, invite, join, remove, leave, close, reconcile, or transit');
+            : 'runtime-host service mesh requires status, create, invite, join, remove, leave, close, reconcile, transit, rename, or rename-mesh');
     }
     let meshId;
     let peerId;
+    let displayName;
+    let clientDataRoot;
     const options = parseManagedServiceOptions(argv.slice(1), {
         allowConfiguration: false,
         allowFramed: true,
         valueOptions: {
+            '--client-data-root': (value) => {
+                if (clientDataRoot !== undefined)
+                    return error('Duplicate --client-data-root');
+                if (!isSafeAbsolutePath(value))
+                    return error('--client-data-root must be an absolute path');
+                clientDataRoot = value;
+            },
             '--mesh': (value) => {
                 if (meshId !== undefined)
                     return error('Duplicate --mesh');
@@ -777,6 +788,14 @@ function parseServicePeerMeshCommand(argv) {
                     return error('--peer requires a valid Peer ID');
                 peerId = value;
             },
+            '--name': (value) => {
+                if (displayName !== undefined)
+                    return error('Duplicate --name');
+                if (!value.trim() || value.trim().length > 80) {
+                    return error('--name requires a display name of at most 80 characters');
+                }
+                displayName = value.trim();
+            },
         },
         flagOptions: {
             '--off': () => {
@@ -784,6 +803,11 @@ function parseServicePeerMeshCommand(argv) {
                     return error('mesh transit accepts either --mesh or --off');
                 meshId = null;
             },
+            '--clear-name': () => {
+                if (displayName !== undefined)
+                    return error('mesh rename accepts --name or --clear-name');
+                displayName = null;
+            },
         },
     });
     if ('kind' in options)
@@ -791,7 +815,11 @@ function parseServicePeerMeshCommand(argv) {
     if (!options.managedRootId || !options.operatorDeploymentId || !options.expectedTarget) {
         return error('runtime-host service mesh requires --managed-root-id, --operator-deployment-id, and an expected target');
     }
-    const needsMesh = action === 'invite' || action === 'remove' || action === 'leave' || action === 'close';
+    const needsMesh = action === 'invite' ||
+        action === 'remove' ||
+        action === 'leave' ||
+        action === 'close' ||
+        action === 'rename-mesh';
     if (needsMesh && typeof meshId !== 'string') {
         return error(`runtime-host service mesh ${action} requires --mesh`);
     }
@@ -809,6 +837,11 @@ function parseServicePeerMeshCommand(argv) {
     if (action === 'transit' && meshId === undefined) {
         return error('runtime-host service mesh transit requires --mesh or --off');
     }
+    if ((action === 'rename' || action === 'rename-mesh') !== (displayName !== undefined)) {
+        return error(action === 'rename'
+            ? 'runtime-host service mesh rename requires --name or --clear-name'
+            : '--name and --clear-name are only valid with mesh rename or rename-mesh');
+    }
     return {
         kind: 'runtime-host-service-peer-mesh',
         action,
@@ -819,6 +852,7 @@ function parseServicePeerMeshCommand(argv) {
         expectedTarget: options.expectedTarget,
         ...(meshId !== undefined ? { meshId } : {}),
         ...(peerId ? { peerId } : {}),
+        ...(displayName !== undefined ? { displayName } : {}),
     };
 }
 function parseUpdatePolicy(value) {

package/dist/runtime-host-peer-mesh-management-command.js

@@ -139,6 +139,23 @@ async function executePeerMeshAction(connection, options, invitation) {
                     meshId: requiredOption(options.meshId, 'Mesh ID'),
                 }),
             };
+        case 'rename':
+            return {
+                kind: 'result',
+                action: 'rename',
+                result: await request('peer.mesh.display-name.set', {
+                    displayName: requiredOption(options.displayName, 'Display name'),
+                }),
+            };
+        case 'rename-mesh':
+            return {
+                kind: 'result',
+                action: 'rename-mesh',
+                result: await request('peer.mesh.rename', {
+                    meshId: requiredMeshId(options.meshId),
+                    displayName: requiredOption(options.displayName, 'Display name'),
+                }),
+            };
     }
 }
 function requiredOption(value, label) {

package/dist/runtime-host-setup-command.js

@@ -22,7 +22,7 @@ import { join, resolve } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { generalizedErrorMessage } from '@maka/core/redaction';
-import { activateRuntimeHostManagedDeployment, connectRemoteRuntimeHost, ensureRuntimeHostPeerIdentity, } from '@maka/runtime-host/client';
+import { activateRuntimeHostManagedDeployment, connectRemoteRuntimeHost, ensureRuntimeHostPeerIdentity, RuntimeHostOperationError, } from '@maka/runtime-host/client';
 import { RuntimeHostManagedDeploymentError as RuntimeHostDeploymentAuthorityError, encodeRuntimeHostSetupFrame, isSha512PackageIntegrity, resolveRuntimeHostManagedDeployment, RUNTIME_HOST_SETUP_ERROR_CODE_MAX_BYTES, RUNTIME_HOST_SETUP_ERROR_MESSAGE_MAX_BYTES, } from '@maka/runtime-host/operator';
 import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { prepareRuntimeHostAccessCredential, replaceRuntimeHostAccessCredential, revokeRuntimeHostAccessCredential, RuntimeHostAccessUnavailableError, } from './runtime-host-access-command.js';
@@ -34,7 +34,7 @@ import { repairStorageRootAfterRemount, resolveStorageRoot } from '@maka/storage
 import { createPlatformRuntimeHostServiceBackend, discoverRuntimeHostLifecycleProvider, resolveRuntimeHostLifecycleProvider, } from './runtime-host-service-management-command.js';
 import { allocateRuntimeHostLoopbackPort, allocateRuntimeHostPeerPort, effectiveRuntimeHostProjectDirectoryRoots, manageRuntimeHostService, readRuntimeHostManagedServiceConfig, removeRuntimeHostServiceFile, resolveRuntimeHostManagedServiceConfigPath, resolveRuntimeHostManagedServiceId, resolveRuntimeHostManagedProjectDirectoryRoots, RuntimeHostServiceManagerError, withRuntimeHostManagedServiceDeploymentLock, withRuntimeHostManagedServiceLifecycleLock, } from './runtime-host-service-manager.js';
 import { expandWildcardListenAddresses } from './runtime-host-peer-management-command.js';
-import { canDiscardRuntimeHostLifecycleDesiredArtifacts, replaceRuntimeHostLifecycle, resolveRecoverableRuntimeHostManagedDeployment, RUNTIME_HOST_READY_TIMEOUT_MS, } from './runtime-host-lifecycle-transaction.js';
+import { canDiscardRuntimeHostLifecycleDesiredArtifacts, replaceRuntimeHostLifecycle, resolveRecoverableRuntimeHostManagedDeployment, RUNTIME_HOST_READY_TIMEOUT_MS, RuntimeHostLifecycleTransactionError, } from './runtime-host-lifecycle-transaction.js';
 import { resolveRuntimeHostManagedPeerKeyPath, resolveRuntimeHostPeerNativePath, } from './runtime-host-peer-artifact.js';
 import { activateRuntimeHostManagedDeploymentWithReconciliation } from './runtime-host-activation-command.js';
 const SETUP_LOCK_TIMEOUT_MS = 5 * 60_000;
@@ -192,12 +192,13 @@ async function runRuntimeHostSupervisedSetupLocked(options, deps, emit) {
         await assertLegacyArtifactsAbsent(legacyBackend);
     if (legacyToMigrate)
         await assertCompatibleExistingVersion(legacyStatus, options.version);
-    if (current && current.launch.package.version !== options.version) {
+    if (current && current.launch.package.version !== options.version && !options.updateExisting) {
         throw new RuntimeHostSetupError('version_change_requires_update', `Runtime Host ${current.launch.package.version} is already installed; changing to ${options.version} requires the update workflow`);
     }
     const resolvedPackage = await resolveRuntimeHostSetupPackage(options, deps);
     const { candidate } = resolvedPackage;
-    if (current && !sameExactPackage(current, candidate)) {
+    const packageChanged = current !== undefined && !sameExactPackage(current, candidate);
+    if (current && packageChanged && !options.updateExisting) {
         throw new RuntimeHostSetupError('version_change_requires_update', `Runtime Host ${current.launch.package.version} is already installed; changing its exact package requires the update workflow`);
     }
     const lifecycleOffer = current?.lifecycle.mode === 'supervised'
@@ -214,14 +215,16 @@ async function runRuntimeHostSupervisedSetupLocked(options, deps, emit) {
             sourcePackageRoot: packageRoot,
             version: candidate.version,
             packageIntegrity: candidate.integrity,
+            ...(current ? { deploymentRoot: current.deploymentRoot } : {}),
         });
         let committed = false;
         try {
             const desired = await prepareSupervisedDeploymentConfig(options, deps, capability, deployment.cliPath, deployment.root, candidate, current, legacyToMigrate, lifecycleOffer);
-            if (current && !sameDesiredManagedDeployment(current, desired)) {
-                if (current.lifecycle.mode === 'supervised') {
-                    throw new RuntimeHostSetupError('configuration_changed', 'Change an existing supervised Runtime Host through its explicit configure or update workflow');
-                }
+            if (current &&
+                !sameDesiredManagedDeployment(current, desired) &&
+                !options.updateExisting &&
+                current.lifecycle.mode === 'supervised') {
+                throw new RuntimeHostSetupError('configuration_changed', 'Change an existing supervised Runtime Host through its explicit configure or update workflow');
             }
             emit({ kind: 'progress', phase: 'installing_service' });
             if (legacyToMigrate) {
@@ -233,9 +236,11 @@ async function runRuntimeHostSupervisedSetupLocked(options, deps, emit) {
                 operation: legacyToMigrate
                     ? 'legacy_migration'
                     : current
-                        ? isDeepStrictEqual(current.lifecycle, desired.lifecycle)
-                            ? 'configure'
-                            : 'lifecycle_change'
+                        ? packageChanged
+                            ? 'update'
+                            : isDeepStrictEqual(current.lifecycle, desired.lifecycle)
+                                ? 'configure'
+                                : 'lifecycle_change'
                         : 'install',
                 ...(current ? { current } : {}),
                 desired,
@@ -247,6 +252,7 @@ async function runRuntimeHostSupervisedSetupLocked(options, deps, emit) {
                             .then(() => undefined),
                     }
                     : {}),
+                allowInterruptActiveTasks: Boolean(current && packageChanged && options.updateExisting),
                 deps: lifecycleDeps,
             });
             if (replacement.kind === 'active_tasks') {
@@ -286,8 +292,13 @@ async function runRuntimeHostSupervisedSetupLocked(options, deps, emit) {
             };
         }
         catch (error) {
-            if (!current && !committed && canDiscardRuntimeHostLifecycleDesiredArtifacts(error)) {
-                await removeRuntimeHostManagedDeployment(deployment.root, capability.rootId).catch(() => undefined);
+            if (!committed && canDiscardRuntimeHostLifecycleDesiredArtifacts(error)) {
+                if (current && packageChanged) {
+                    await deployment.rollback().catch(() => undefined);
+                }
+                else if (!current) {
+                    await removeRuntimeHostManagedDeployment(deployment.root, capability.rootId).catch(() => undefined);
+                }
             }
             throw error;
         }
@@ -552,6 +563,7 @@ async function runRuntimeHostOnDemandSetupLocked(options, deps, emit) {
                     activateDesired: async () => {
                         await deps.activateDesired({ rootId: capability.rootId });
                     },
+                    allowInterruptActiveTasks: Boolean(current && packageChanged && options.updateExisting),
                     deps: lifecycleDeps,
                 });
                 if (replacement.kind === 'active_tasks') {
@@ -700,7 +712,7 @@ async function pairAndVerifyRuntimeHostSetup(options, target, deps, emit) {
                 break;
             }
             catch (error) {
-                if (!(error instanceof RuntimeHostAccessUnavailableError) || Date.now() >= deadline) {
+                if (!isTransientPairingAvailabilityError(error) || Date.now() >= deadline) {
                     throw error;
                 }
                 await new Promise((resolveWait) => setTimeout(resolveWait, Math.min(PAIRING_AVAILABILITY_POLL_MS, deadline - Date.now())));
@@ -757,6 +769,11 @@ async function pairAndVerifyRuntimeHostSetup(options, target, deps, emit) {
         throw error;
     }
 }
+function isTransientPairingAvailabilityError(error) {
+    return (error instanceof RuntimeHostAccessUnavailableError ||
+        (error instanceof RuntimeHostOperationError &&
+            (error.code === 'host_not_ready' || error.code === 'host_draining')));
+}
 async function assertCompatibleExistingVersion(status, version) {
     if (!status.service.config) {
         if (!status.service.installed)
@@ -828,7 +845,8 @@ function setupFailure(error) {
         error instanceof RuntimeHostManagedDeploymentError ||
         error instanceof RuntimeHostDeploymentAuthorityError ||
         error instanceof RuntimeHostUpdateDiscoveryError ||
-        error instanceof RuntimeHostUpdatePackageError) {
+        error instanceof RuntimeHostUpdatePackageError ||
+        error instanceof RuntimeHostLifecycleTransactionError) {
         code = error.code;
         message = error.message;
     }

package/dist/runtime-host-systemd-service.js

@@ -127,7 +127,7 @@ export function createSystemdUserRuntimeHostService(serviceId, options) {
             await runLifecycleAction(context, 'restart');
             await ensureSystemdUpdateSchedulerStartedIfInstalled(scheduler);
         },
-        retire: () => runLifecycleAction(context, 'stop'),
+        retire: () => retireSystemdSupervisor(context),
         logs: async () => {
             const readJournal = async (unitName) => {
                 const result = await runJournalctl([
@@ -220,7 +220,7 @@ export function createSystemdUserRuntimeHostLifecycleProvider(serviceId, options
                 await context.runSystemctl(['reset-failed', context.unitName]);
                 await runLifecycleAction(context, 'start');
             },
-            retire: () => runLifecycleAction(context, 'stop'),
+            retire: () => retireSystemdSupervisor(context),
             logs: () => readJournal(context.unitName),
             uninstall: () => uninstallSystemdSupervisor(context),
         },
@@ -507,7 +507,7 @@ async function stopSystemdManagedDeployment(service, scheduler) {
         errors.push(error);
     }
     try {
-        await runLifecycleAction(service, 'stop');
+        await retireSystemdSupervisor(service);
     }
     catch (error) {
         errors.push(error);
@@ -516,6 +516,12 @@ async function stopSystemdManagedDeployment(service, scheduler) {
         throw new RuntimeHostServiceManagerError('service_manager_operation_failed', 'Unable to stop the Runtime Host managed deployment', { cause: new AggregateError(errors) });
     }
 }
+async function retireSystemdSupervisor(context) {
+    const status = await readSystemdStatus(context);
+    if (!isSystemdUnitRunning(status))
+        return;
+    await runLifecycleAction(context, 'stop');
+}
 async function removeSystemdUpdateScheduler(context) {
     const timerStatus = await readSystemdStatus(context.timer);
     await stopSystemdUpdateScheduler(context);

package/node_modules/@maka/runtime/dist/sandbox/macos-seatbelt.js

@@ -16,6 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { readlinkSync, realpathSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
 export const MACOS_SEATBELT_EXECUTABLE = '/usr/bin/sandbox-exec';
 export const MACOS_SEATBELT_BASE_POLICY = `(version 1)
 (deny default)
@@ -301,30 +303,87 @@ function resolveRoots(profile, pathContext) {
         writableRoots,
         deniedRoots,
         protectedWritableRoots: profile.fileSystem.protectedMetadata && writableRoots.length > 0
-            ? uniqueRoots([...protectedWritableRoots, ...pathContext.workspaceRoots])
+            ? uniqueRoots([
+                ...protectedWritableRoots,
+                ...pathContext.workspaceRoots.map(resolveRootPath),
+            ])
             : [],
         protectedMetadataNames: profile.fileSystem.protectedMetadata?.names ?? [],
-        runtimeReadableRoots: uniqueRoots(pathContext.runtimeReadableRoots ?? []),
-        executableRoots: uniqueRoots(pathContext.executableRoots ?? []),
+        runtimeReadableRoots: uniqueRoots((pathContext.runtimeReadableRoots ?? []).map(resolveRootPath)),
+        executableRoots: uniqueRoots((pathContext.executableRoots ?? []).map(resolveRootPath)),
     };
 }
 function rootsForEntry(entry, pathContext) {
     if (entry.kind === 'path') {
-        return [{ path: entry.path, match: entry.match ?? 'subtree' }];
+        return [{ path: resolveRootPath(entry.path), match: entry.match ?? 'subtree' }];
     }
     switch (entry.special) {
         case ':root':
-            return [{ path: '/', match: 'subtree' }];
+            return [{ path: resolveRootPath('/'), match: 'subtree' }];
         case ':workspace_roots':
-            return pathContext.workspaceRoots.map((path) => ({ path, match: 'subtree' }));
+            return pathContext.workspaceRoots.map((path) => ({
+                path: resolveRootPath(path),
+                match: 'subtree',
+            }));
         case ':tmpdir':
-            return pathContext.tmpdir ? [{ path: pathContext.tmpdir, match: 'subtree' }] : [];
+            return pathContext.tmpdir
+                ? [{ path: resolveRootPath(pathContext.tmpdir), match: 'subtree' }]
+                : [];
         case ':slash_tmp':
-            return [{ path: pathContext.slashTmp ?? '/tmp', match: 'subtree' }];
+            return [{ path: resolveRootPath(pathContext.slashTmp ?? '/tmp'), match: 'subtree' }];
         case ':minimal':
-            return (pathContext.minimalRoots ?? []).map((path) => ({ path, match: 'subtree' }));
+            return (pathContext.minimalRoots ?? []).map((path) => ({
+                path: resolveRootPath(path),
+                match: 'subtree',
+            }));
     }
 }
+const MAX_DANGLING_SYMLINK_HOPS = 40;
+/**
+ * Seatbelt evaluates kernel-resolved paths, so every root must be emitted in
+ * canonical form. A root may not exist yet (a deny for a file that has not
+ * been created), so canonicalize the deepest existing ancestor and re-append
+ * the missing tail, mirroring `realpathAllowMissing`; an allow and its deny
+ * then stay in the same path space. Any other resolution failure (EACCES,
+ * ELOOP, ...) propagates and fails policy construction: emitting a root in
+ * lexical path space could split an allow from its deny across aliases.
+ */
+function resolveRootPath(path) {
+    let cursor = resolve(path);
+    const missing = [];
+    let hops = 0;
+    while (true) {
+        try {
+            return resolve(realpathSync(cursor), ...missing.reverse());
+        }
+        catch (error) {
+            if (!isMissingPathError(error))
+                throw error;
+            let link = null;
+            try {
+                link = readlinkSync(cursor);
+            }
+            catch {
+                link = null;
+            }
+            if (link !== null) {
+                if (++hops > MAX_DANGLING_SYMLINK_HOPS)
+                    throw new Error(`Root ${JSON.stringify(path)} traverses too many dangling symlinks.`);
+                cursor = resolve(dirname(cursor), link);
+                continue;
+            }
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                throw error;
+            missing.push(basename(cursor));
+            cursor = parent;
+        }
+    }
+}
+function isMissingPathError(error) {
+    const code = error?.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
 function addUniqueResolvedRoots(target, roots) {
     for (const root of roots) {
         if (!target.some((existing) => existing.path === root.path && existing.match === root.match)) {

package/node_modules/@maka/runtime-host/dist/client/peer-client.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { RuntimeHostPeerError, signRuntimeHostPeerIdentity, startRuntimeHostPeerEndpoint, verifyRuntimeHostPeerIdentity, } from '../transport/peer-native.js';
+import { normalizePeerError, RuntimeHostPeerError, signRuntimeHostPeerIdentity, startRuntimeHostPeerEndpoint, verifyRuntimeHostPeerIdentity, } from '../transport/peer-native.js';
 import { RuntimeHostPermanentReconnectError } from './reconnect-lifecycle.js';
 export function createRuntimeHostPeerClientFromEnvironment(environment = process.env, options = {}) {
     const nativePath = environment.MAKA_RUNTIME_HOST_PEER_NATIVE_PATH;
@@ -86,11 +86,30 @@ class RuntimeHostPeerClientImpl {
         return Object.freeze({ ...this.#requireEndpoint().transitSnapshot });
     }
     configureTransit(input) {
-        return this.#requireEndpoint().configureTransit(input);
+        return this.#requireEndpoint()
+            .configureTransit(input)
+            .catch((error) => {
+            throw normalizePeerError(error);
+        });
     }
     async connect(input, signal) {
+        await this.#prepareRoutes(input, signal);
         return this.#connect(input, signal, 'application');
     }
+    async #prepareRoutes(input, signal) {
+        if (!this.#routeResolver?.prepareRoutes)
+            return;
+        const deadline = AbortSignal.timeout(Math.min(10_000, input.directDeadlineMs));
+        const operationSignal = signal ? AbortSignal.any([signal, deadline]) : deadline;
+        try {
+            await this.#routeResolver.prepareRoutes(input.peerId, operationSignal);
+        }
+        catch {
+            // Route preparation enriches an invitation/profile with fresher Mesh
+            // routes. It must not suppress explicit routes the caller already has.
+            signal?.throwIfAborted();
+        }
+    }
     async connectMeshControl(input, signal) {
         return this.#connect(input, signal, 'mesh-control');
     }
@@ -193,7 +212,7 @@ class RuntimeHostPeerClientImpl {
         }
         catch (error) {
             signal?.throwIfAborted();
-            throw error;
+            throw normalizePeerError(error);
         }
         finally {
             settled = true;

package/node_modules/@maka/runtime-host/dist/operator/peer-mesh-management-frame.js

@@ -30,6 +30,8 @@ const ACTION_SCHEMA = z.enum([
     'close',
     'reconcile',
     'transit',
+    'rename',
+    'rename-mesh',
 ]);
 const FRAME_SCHEMA = z.union([
     z.object({ kind: z.literal('input'), action: z.literal('join') }).strict(),
@@ -93,6 +95,18 @@ function decodeFrame(value) {
                 action: 'transit',
                 result: decodePeerMeshQueryResult(frame.result),
             };
+        case 'rename':
+            return {
+                kind: 'result',
+                action: 'rename',
+                result: decodePeerMeshQueryResult(frame.result),
+            };
+        case 'rename-mesh':
+            return {
+                kind: 'result',
+                action: 'rename-mesh',
+                result: decodePeerMeshQueryResult(frame.result),
+            };
         case 'invite':
             return {
                 kind: 'result',

package/node_modules/@maka/runtime-host/dist/peer-mesh/display-name.js

@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export const PEER_MESH_DISPLAY_NAME_MAX_LENGTH = 80;
+export function canonicalPeerMeshDisplayName(value) {
+    if (typeof value !== 'string')
+        throw new Error('Invalid Peer Mesh display name');
+    const displayName = value.trim();
+    if (displayName.length === 0 ||
+        displayName.length > PEER_MESH_DISPLAY_NAME_MAX_LENGTH ||
+        /[\u0000-\u001f\u007f]/u.test(displayName)) {
+        throw new Error('Invalid Peer Mesh display name');
+    }
+    return displayName;
+}

package/node_modules/@maka/runtime-host/dist/peer-mesh/model.js

@@ -19,6 +19,7 @@
 import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, sign, timingSafeEqual, verify, } from 'node:crypto';
 import { decodePeerMeshInvitation as decodePeerMeshInvitationWire, } from '../protocol/peer-mesh.js';
 import { PEER_MESH_MAX_MEMBERS, PEER_MESH_MAX_ROUTE_HINTS, PEER_MESH_ROUTE_RECORD_MAX_BYTES, } from './limits.js';
+import { canonicalPeerMeshDisplayName } from './display-name.js';
 export { PEER_MESH_MAX_INVITATION_RECORDS, PEER_MESH_MAX_MEMBERS, PEER_MESH_MAX_MESHES, PEER_MESH_MAX_PENDING_INVITATIONS, PEER_MESH_MAX_ROUTE_HINTS, PEER_MESH_MAX_TRANSIT_ADDRESSES_PER_RELAY, PEER_MESH_MAX_TRANSIT_RELAY_ADDRESSES, PEER_MESH_ROUTE_RECORD_MAX_BYTES, } from './limits.js';
 export function generatePeerMeshAuthorityKeyPair() {
     const { publicKey, privateKey } = generateKeyPairSync('ed25519');
@@ -114,13 +115,12 @@ export function validatePeerMeshInvitation(value) {
     });
 }
 export function canonicalPeerMeshRoster(value) {
-    const record = exactObject(value, 'Peer Mesh roster', [
-        'version',
-        'meshId',
-        'revision',
-        'members',
-        'closed',
-    ]);
+    const keys = ['version', 'meshId', 'revision', 'members', 'closed'];
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        if (Object.hasOwn(value, 'displayName'))
+            keys.push('displayName');
+    }
+    const record = exactObject(value, 'Peer Mesh roster', keys);
     if (record.version !== 1)
         throw new Error('Unsupported Peer Mesh roster version');
     const members = stringArray(record.members, 'members', PEER_MESH_MAX_MEMBERS, 256)
@@ -137,6 +137,9 @@ export function canonicalPeerMeshRoster(value) {
         revision: integer(record.revision, 'revision', 1),
         members: Object.freeze(members),
         closed: record.closed,
+        ...(record.displayName === undefined
+            ? {}
+            : { displayName: canonicalPeerMeshDisplayName(record.displayName) }),
     });
 }
 export function decodeAuthorityTarget(value) {
@@ -152,22 +155,23 @@ export function decodeAuthorityTarget(value) {
     });
 }
 export function canonicalPeerMeshRouteRecord(value) {
-    const baseKeys = [
-        'version',
-        'peerId',
-        'sequence',
-        'expiresAt',
-        'routeHints',
-        'coordinationRelays',
-    ];
-    const record = exactObject(value, 'Peer Mesh route record', value &&
-        typeof value === 'object' &&
-        !Array.isArray(value) &&
-        Object.hasOwn(value, 'transitMeshId')
-        ? [...baseKeys, 'transitMeshId']
-        : baseKeys);
+    const keys = ['version', 'peerId', 'sequence', 'expiresAt', 'routeHints', 'coordinationRelays'];
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        if (Object.hasOwn(value, 'endpointKind'))
+            keys.push('endpointKind');
+        if (Object.hasOwn(value, 'displayName'))
+            keys.push('displayName');
+        if (Object.hasOwn(value, 'transitMeshId'))
+            keys.push('transitMeshId');
+    }
+    const record = exactObject(value, 'Peer Mesh route record', keys);
     if (record.version !== 1)
         throw new Error('Unsupported Peer Mesh route record version');
+    if (record.endpointKind !== undefined &&
+        record.endpointKind !== 'client' &&
+        record.endpointKind !== 'host') {
+        throw new Error('Invalid Peer Mesh endpoint kind');
+    }
     const route = Object.freeze({
         version: 1,
         peerId: token(record.peerId, 'peerId', 256),
@@ -175,6 +179,10 @@ export function canonicalPeerMeshRouteRecord(value) {
         expiresAt: integer(record.expiresAt, 'route expiry', 1),
         routeHints: Object.freeze(addressArray(record.routeHints, 'routeHints')),
         coordinationRelays: Object.freeze(addressArray(record.coordinationRelays, 'coordinationRelays')),
+        ...(record.endpointKind === undefined ? {} : { endpointKind: record.endpointKind }),
+        ...(record.displayName === undefined
+            ? {}
+            : { displayName: canonicalPeerMeshDisplayName(record.displayName) }),
         ...(record.transitMeshId === undefined
             ? {}
             : { transitMeshId: string(record.transitMeshId, 'transitMeshId', 128) }),
@@ -201,6 +209,8 @@ export function decodeSignedPeerMeshRouteRecord(value) {
 export function peerMeshRouteRecordSigningBytes(route) {
     return Buffer.from(`maka.peer-mesh.route.v1\n${JSON.stringify({
         coordinationRelays: route.coordinationRelays,
+        ...(route.displayName ? { displayName: route.displayName } : {}),
+        ...(route.endpointKind ? { endpointKind: route.endpointKind } : {}),
         expiresAt: route.expiresAt,
         peerId: route.peerId,
         routeHints: route.routeHints,
@@ -212,6 +222,7 @@ export function peerMeshRouteRecordSigningBytes(route) {
 function encodeRoster(roster) {
     return Buffer.from(`maka.peer-mesh.roster.v1\n${JSON.stringify({
         closed: roster.closed,
+        ...(roster.displayName ? { displayName: roster.displayName } : {}),
         members: roster.members,
         meshId: roster.meshId,
         revision: roster.revision,