You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maka.apache.org by wy...@apache.org on 2026/09/02 01:36:22 UTC
(maka) 01/02: fix(peer): keep Mesh and shared-session routes live (#4444)
This is an automated email from the ASF dual-hosted git repository.
M4n5ter pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/maka.git
commit 9b558863018e7c7c9c007e1821807114da3d4bf3
Author: Wang <m4...@gmail.com>
AuthorDate: Wed Sep 2 09:36:10 2026 +0800
fix(peer): keep Mesh and shared-session routes live (#4444)
* fix(desktop): issue live peer routes for shared sessions
Generated-by: Codex
* fix(peer): expose live relay routes to shared sessions
* fix(desktop): surface pending turn requests
* fix(peer): recover idle shared-session connections
* fix(desktop): keep collaboration hook scope observable
* fix(desktop): streamline collaboration invitation transfer
* fix(desktop): preserve available collaboration inboxes
* fix(peer): retain authenticated guest routes
* fix(desktop): compact turn approval prompt
* docs(pr): refresh turn approval screenshot
* chore: remove PR screenshot asset
* fix(desktop): preserve Session rail render isolation
* docs(ui): refresh Astryx surface inventory
* test(peer): make route refresh liveness deterministic
---
apps/desktop/renderer-architecture.json | 18 +-
.../runtime-host-collaboration-ipc-main.test.ts | 55 ++++-
.../runtime-host-guest-session-mounts.test.ts | 115 ++++++++++-
.../runtime-host-local-remote-access.test.ts | 94 ++++++++-
.../__tests__/runtime-host-profile-service.test.ts | 45 +++-
.../runtime-host-session-catalog-preload.test.ts | 97 +++++++--
...runtime-host-turn-request-inbox-preload.test.ts | 49 +++++
.../session-turn-request-inbox-model.test.ts | 64 ++++++
apps/desktop/src/main/runtime-host-boot.ts | 14 +-
apps/desktop/src/main/runtime-host-client.ts | 12 +-
.../main/runtime-host-collaboration-invitation.ts | 7 +-
.../main/runtime-host-collaboration-ipc-main.ts | 11 +-
.../src/main/runtime-host-desktop-candidate.ts | 5 +
.../src/main/runtime-host-desktop-manager.ts | 8 +-
.../src/main/runtime-host-guest-session-mounts.ts | 63 +++++-
.../src/main/runtime-host-local-remote-access.ts | 30 ++-
.../src/main/runtime-host-profile-service.ts | 48 ++++-
apps/desktop/src/preload/bridge-contract.d.ts | 13 +-
apps/desktop/src/preload/preload.ts | 69 +++++--
.../src/preload/runtime-host-session-catalog.ts | 54 +++--
.../runtime-host-turn-request-inbox.ts} | 32 +--
apps/desktop/src/renderer/app-shell.tsx | 48 +++--
.../use-session-collaboration-dialog.ts | 12 ++
.../controller/use-turn-request-inbox.ts | 142 +++++++++++++
.../features/session-collaboration/index.ts | 4 +
.../model/turn-request-inbox.ts | 62 ++++++
.../features/session-collaboration/ports.ts | 11 +
.../session-collaboration/{index.ts => testing.ts} | 9 +-
.../turn-request-inbox-context.tsx | 72 +++++++
.../ui/session-collaboration-join-dialog.tsx | 44 +++-
.../ui/session-turn-request-approval.tsx | 107 ++++++++++
.../ui/session-turn-request-badge.tsx} | 26 +--
.../ui/session-navigation-provider.tsx | 16 +-
.../renderer/locales/session-collaboration-copy.ts | 38 +++-
.../create-session-collaboration-services.ts | 4 +
.../src/renderer/session-collaboration-dialog.tsx | 77 +++++--
.../src/renderer/styles/settings/runtime-host.css | 5 +
apps/desktop/src/renderer/styles/shell-layout.css | 48 +++++
apps/desktop/src/renderer/styles/sidebar.css | 5 +
docs/astryx-surface-file-inventory.md | 7 +-
docs/astryx-surface-file-inventory.paths | 3 +
native/runtime-host-peer/src/engine.rs | 226 +++++++++++++--------
.../__tests__/execution-service-listeners.test.ts | 62 ++++++
.../src/__tests__/peer-listener.test.ts | 29 +++
.../runtime-host/src/__tests__/peer-mesh.test.ts | 84 +++++++-
.../runtime-host/src/__tests__/peer-native.test.ts | 57 +++++-
.../runtime-host/src/__tests__/protocol.test.ts | 30 +++
.../session-collaboration-authority.test.ts | 53 ++++-
.../__tests__/session-subscription-client.test.ts | 41 ++++
packages/runtime-host/src/client/connection.ts | 63 +++---
packages/runtime-host/src/client/host-profile.ts | 24 ++-
packages/runtime-host/src/client/peer-client.ts | 42 +++-
packages/runtime-host/src/peer-mesh/node.ts | 82 ++++++--
packages/runtime-host/src/peer-mesh/owner.ts | 4 +
packages/runtime-host/src/protocol/host-status.ts | 46 +++++
packages/runtime-host/src/protocol/index.ts | 5 +-
packages/runtime-host/src/protocol/operations.ts | 1 +
.../src/protocol/session-collaboration.ts | 9 +-
.../runtime-host/src/server/access-authority.ts | 3 +-
.../runtime-host/src/server/execution-service.ts | 5 +-
packages/runtime-host/src/server/host-kernel.ts | 10 +
packages/runtime-host/src/server/listener-set.ts | 22 +-
packages/runtime-host/src/server/peer-listener.ts | 4 +
packages/ui/src/session-history-list.tsx | 8 +
packages/ui/src/session-rail-context.tsx | 1 +
65 files changed, 2223 insertions(+), 331 deletions(-)
diff --git a/apps/desktop/renderer-architecture.json b/apps/desktop/renderer-architecture.json
index 36e9bb5369..fc1b4e558b 100644
--- a/apps/desktop/renderer-architecture.json
+++ b/apps/desktop/renderer-architecture.json
@@ -234,7 +234,6 @@
"src/renderer/use-new-task-choice.ts",
"src/renderer/use-onboarding-snapshot.ts",
"src/renderer/use-project-context.ts",
- "src/renderer/use-session-collaboration-dialog.ts",
"src/renderer/use-session-setting-intent.ts",
"src/renderer/use-settings-modal.ts",
"src/renderer/use-shell-appearance.ts",
@@ -985,6 +984,7 @@
"./error-boundary": 1,
"./features/goals": 1,
"./features/module-hub": 1,
+ "./features/session-collaboration": 1,
"./features/session-navigation": 1,
"./features/task-entry": 1,
"./features/workbar": 1,
@@ -1020,7 +1020,6 @@
"./use-new-task-choice": 1,
"./use-onboarding-snapshot": 1,
"./use-project-context": 1,
- "./use-session-collaboration-dialog": 1,
"./use-session-setting-intent": 1,
"./use-settings-modal": 1,
"./use-shell-appearance": 1,
@@ -1058,7 +1057,7 @@
"react": 1
},
"importSpecifiers": 186,
- "nonTriviaTokens": 15825
+ "nonTriviaTokens": 15800
},
"src/renderer/use-app-shell-composer-quotes.ts": {
"importDeclarations": 3,
@@ -4927,19 +4926,6 @@
"react": 1
}
},
- "src/renderer/use-session-collaboration-dialog.ts": {
- "bridgePaths": {},
- "environmentCapabilities": {},
- "hookCalls": {
- "useState": 1
- },
- "lifecycleMethods": {},
- "unresolvedDependencies": 0,
- "actionFactories": [],
- "dependencyPaths": {
- "react": 1
- }
- },
"src/renderer/use-session-setting-intent.ts": {
"bridgePaths": {},
"environmentCapabilities": {},
diff --git a/apps/desktop/src/main/__tests__/runtime-host-collaboration-ipc-main.test.ts b/apps/desktop/src/main/__tests__/runtime-host-collaboration-ipc-main.test.ts
index 2863fec8e2..ce64f26182 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-collaboration-ipc-main.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-collaboration-ipc-main.test.ts
@@ -29,7 +29,7 @@ import { registerRuntimeHostCollaborationIpc } from '../runtime-host-collaborati
const ROOT_ID = 'a'.repeat(64);
-test('requires Owner confirmation before issuing a plaintext collaboration invitation', async () => {
+test('requires plaintext confirmation and reports the issued invitation routes', async () => {
const handlers = new Map<string, IpcHandler>();
const ipcMain: ReconnectableReadIpcMain = {
handle(channel, listener) {
@@ -37,6 +37,7 @@ test('requires Owner confirmation before issuing a plaintext collaboration invit
},
};
let prepareCalls = 0;
+ const queryCalls: Array<string | undefined> = [];
const client = {
async prepareCollaborationInvitation(sessionId: string, grantKinds: readonly string[]) {
prepareCalls += 1;
@@ -56,6 +57,10 @@ test('requires Owner confirmation before issuing a plaintext collaboration invit
async queryCollaborationAccess() {
return { principals: [], grants: [] };
},
+ async queryCollaborationTurnRequests(sessionId?: string) {
+ queryCalls.push(sessionId);
+ return { canRequestTurns: false, requests: [] };
+ },
async revokeCollaborationPrincipal() {
return { revoked: false };
},
@@ -92,9 +97,55 @@ test('requires Owner confirmation before issuing a plaintext collaboration invit
assert.equal(prepareCalls, 1);
assert.equal((result as { kind?: unknown }).kind, 'prepared');
const invitation = (result as {
- invitation: { invitationCode: string };
+ invitation: { invitationCode: string; connectivity: unknown };
}).invitation;
+ assert.deepEqual(invitation.connectivity, { kind: 'configured' });
const bundle = decodeDesktopCollaborationInvitation(invitation.invitationCode);
assert.equal(decodeCollaborationInvitationCode(bundle.invitationCode).rootId, ROOT_ID);
assert.equal(bundle.target.transport.kind, 'plaintext');
+
+ const query = handlers.get('session-collaboration:turn-request:query');
+ assert.ok(query);
+ assert.deepEqual(await query({} as Parameters<IpcHandler>[0]), {
+ canRequestTurns: false,
+ requests: [],
+ });
+ assert.deepEqual(await query({} as Parameters<IpcHandler>[0], 'session-1'), {
+ canRequestTurns: false,
+ requests: [],
+ });
+ assert.deepEqual(queryCalls, [undefined, 'session-1']);
+
+ const peerHandlers = new Map<string, IpcHandler>();
+ registerRuntimeHostCollaborationIpc(
+ client as unknown as Parameters<typeof registerRuntimeHostCollaborationIpc>[0],
+ {
+ handle(channel, listener) {
+ peerHandlers.set(channel, listener);
+ },
+ },
+ async () => ({
+ name: 'Peer Lab',
+ transport: {
+ kind: 'libp2p-direct',
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays: [
+ '/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay',
+ ],
+ },
+ }),
+ );
+ const preparePeer = peerHandlers.get('session-collaboration:prepare');
+ assert.ok(preparePeer);
+ const peerResult = await preparePeer(
+ {} as Parameters<IpcHandler>[0],
+ 'session-1',
+ 'observe',
+ false,
+ );
+ assert.deepEqual(
+ (peerResult as { invitation: { connectivity: unknown } }).invitation.connectivity,
+ { kind: 'peer', coordinationRelayCount: 1 },
+ );
});
diff --git a/apps/desktop/src/main/__tests__/runtime-host-guest-session-mounts.test.ts b/apps/desktop/src/main/__tests__/runtime-host-guest-session-mounts.test.ts
index 3d8102b844..ba5ee594c5 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-guest-session-mounts.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-guest-session-mounts.test.ts
@@ -19,12 +19,17 @@
import assert from 'node:assert/strict';
import test from 'node:test';
-import { encodeCollaborationInvitationCode } from '@maka/runtime-host/protocol';
+import type { ResolvedRuntimeHostProfile } from '@maka/runtime-host/client';
+import {
+ encodeCollaborationInvitationCode,
+ type HostPeerEndpoint,
+} from '@maka/runtime-host/protocol';
import { encodeDesktopCollaborationInvitation } from '../runtime-host-collaboration-invitation.js';
import {
createDesktopGuestSessionMountService,
type GuestSessionMount,
type GuestSessionMountStore,
+ registerDesktopGuestSessionMountIpc,
} from '../runtime-host-guest-session-mounts.js';
import { RuntimeHostPairingFinalizationInterruptedError } from '../runtime-host-desktop-manager.js';
@@ -56,6 +61,49 @@ test('retains a successful Guest mount and rehydrates the same authority after r
await second!.close();
});
+test('persists authenticated route rotation for reconnect and restart', async () => {
+ const store = memoryStore();
+ let observePeerEndpoint!: (endpoint: HostPeerEndpoint) => void;
+ const first = service(store, {
+ mount: async (target, _signal, _onConnectionPhase, onPeerEndpoint) => {
+ assert.deepEqual(
+ target.profile.kind === 'remote' ? target.profile.transport : undefined,
+ {
+ kind: 'libp2p-direct',
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays: ['/memory/stale-relay'],
+ },
+ );
+ assert.ok(onPeerEndpoint);
+ observePeerEndpoint = onPeerEndpoint;
+ },
+ });
+
+ const imported = await first.importInvitation(peerInvitation('guest-routes'), false, 'routes');
+ assert.equal(imported.kind, 'connected');
+ observePeerEndpoint({
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/198.51.100.2/udp/42000/quic-v1'],
+ coordinationRelays: ['/memory/fresh-relay'],
+ });
+ await first.close();
+
+ let restarted!: ReturnType<typeof service>;
+ const restartedTarget = new Promise<ResolvedRuntimeHostProfile>((resolve) => {
+ restarted = service(store, { mount: async (target) => resolve(target) });
+ void restarted.start();
+ });
+ const target = await restartedTarget;
+ assert.deepEqual(target.profile.kind === 'remote' ? target.profile.transport : undefined, {
+ kind: 'libp2p-direct',
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/198.51.100.2/udp/42000/quic-v1'],
+ coordinationRelays: ['/memory/fresh-relay'],
+ });
+ await restarted.close();
+});
+
test('removes failed activation desire instead of creating recoverable profile state', async () => {
const store = memoryStore();
const unmounted: string[] = [];
@@ -273,6 +321,52 @@ test('cancels an in-flight import and removes its durable mount desire', async (
await mounts.close();
});
+test('reads an invitation from the clipboard only on explicit IPC invocation', async () => {
+ type IpcHandler = Parameters<Pick<Electron.IpcMain, 'handle'>['handle']>[1];
+ const handlers = new Map<string, IpcHandler>();
+ let clipboardReads = 0;
+ const clipboardInvitation = invitation('guest-clipboard');
+ let clipboardText = ` ${clipboardInvitation} `;
+ const mounts = service(memoryStore());
+ const dispose = registerDesktopGuestSessionMountIpc(
+ {
+ handle(channel, handler) {
+ handlers.set(channel, handler);
+ },
+ removeHandler(channel) {
+ handlers.delete(channel);
+ },
+ },
+ mounts,
+ () => {
+ clipboardReads += 1;
+ return clipboardText;
+ },
+ );
+
+ assert.equal(clipboardReads, 0);
+ const handler = handlers.get('session-collaboration:invitation:read-clipboard');
+ assert.ok(handler);
+ assert.equal(await handler({} as never), clipboardInvitation);
+ assert.equal(clipboardReads, 1);
+
+ clipboardText = 'an unrelated clipboard secret';
+ assert.throws(() => handler({} as never), /Invalid Desktop collaboration invitation/);
+
+ clipboardText = ' ';
+ assert.equal(await handler({} as never), '');
+
+ clipboardText = 'x'.repeat(32 * 1024 + 1);
+ assert.throws(
+ () => handler({} as never),
+ /Clipboard content is too large to be a shared Session invitation/,
+ );
+
+ dispose();
+ assert.equal(handlers.size, 0);
+ await mounts.close();
+});
+
function service(
store: GuestSessionMountStore,
overrides: {
@@ -314,6 +408,25 @@ function invitation(credential: string): string {
});
}
+function peerInvitation(credential: string): string {
+ return encodeDesktopCollaborationInvitation({
+ invitationCode: encodeCollaborationInvitationCode({
+ schemaVersion: 1,
+ rootId: ROOT_ID,
+ credential,
+ }),
+ target: {
+ name: 'Shared Host',
+ transport: {
+ kind: 'libp2p-direct',
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays: ['/memory/stale-relay'],
+ },
+ },
+ });
+}
+
function retainedMount(mountId: string): GuestSessionMount {
return {
mountId,
diff --git a/apps/desktop/src/main/__tests__/runtime-host-local-remote-access.test.ts b/apps/desktop/src/main/__tests__/runtime-host-local-remote-access.test.ts
index 9e502095c6..c6f2e90813 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-local-remote-access.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-local-remote-access.test.ts
@@ -44,17 +44,36 @@ test('enabling remote access hands the same root to one managed service before D
const handlers = new Map<string, Parameters<Electron.IpcMain['handle']>[1]>();
let retired = false;
let resumed = false;
+ const peer = {
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays: [],
+ };
+ const livePeer = {
+ ...peer,
+ coordinationRelays: ['/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay'],
+ };
const manager = {
async retireOwnedLocalHost() {
retired = true;
return { kind: 'retired' as const, resume: () => { resumed = true; } };
},
+ async waitUntilReady(profileId: string) {
+ assert.equal(profileId, 'local');
+ },
+ current(profileId: string) {
+ assert.equal(profileId, 'local');
+ return {
+ candidate: {
+ client: {
+ async status() {
+ return { peerEndpoint: livePeer };
+ },
+ },
+ },
+ };
+ },
} as unknown as RuntimeHostDesktopManager;
- const peer = {
- peerId: '12D3KooWpeer',
- routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
- coordinationRelays: [],
- };
const deploymentId = '11111111-1111-4111-8111-111111111111';
const operator = {
async runSetup(input: {
@@ -123,7 +142,7 @@ test('enabling remote access hands the same root to one managed service before D
assert.deepEqual(decodeRuntimeHostOwnerConnectionCode(result.connectionCode), {
name: decodeRuntimeHostOwnerConnectionCode(result.connectionCode).name,
rootId: 'a'.repeat(64),
- transport: { kind: 'libp2p-direct', ...peer },
+ transport: { kind: 'libp2p-direct', ...livePeer },
credential: 'pending-credential',
});
const lifecycle = JSON.parse(
@@ -134,6 +153,69 @@ test('enabling remote access hands the same root to one managed service before D
assert.equal(lifecycle.deploymentId, deploymentId);
});
+test('shares the running Local Host endpoint instead of its persisted startup routes', async (t) => {
+ const base = await mkdtemp(join(tmpdir(), 'maka-local-live-peer-share-'));
+ t.after(() => rm(base, { recursive: true, force: true }));
+ const clientDataRoot = join(base, 'client');
+ const rootPath = join(clientDataRoot, 'workspaces', 'default');
+ const rootId = 'a'.repeat(64);
+ await mkdir(rootPath, { recursive: true });
+ await writeManagedLifecycle(clientDataRoot, rootPath, rootId);
+ const configuredPeer = {
+ peerId: '12D3KooWpeer',
+ routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays: [],
+ };
+ const livePeer = {
+ ...configuredPeer,
+ coordinationRelays: ['/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay'],
+ };
+ const service = createDesktopLocalRuntimeHostRemoteAccess({
+ ipcMain: { handle() {}, removeHandler() {} },
+ clientDataRoot,
+ rootPath,
+ rootId,
+ directPeerAvailable: true,
+ manager: () =>
+ ({
+ current() {
+ return {
+ candidate: {
+ client: {
+ async status() {
+ return { peerEndpoint: livePeer };
+ },
+ },
+ },
+ };
+ },
+ }) as unknown as RuntimeHostDesktopManager,
+ resolveSetupPackage: async () => ({ kind: 'npm', specifier: 'maka-agent@0.2.0' }),
+ operator: {
+ async runPeer() {
+ return {
+ kind: 'result' as const,
+ action: 'status' as const,
+ status: {
+ state: 'enabled' as const,
+ serviceState: 'running',
+ rootId,
+ ...configuredPeer,
+ },
+ };
+ },
+ async close() {},
+ } as unknown as ReturnType<typeof createDesktopRuntimeHostLocalOperator>,
+ });
+ t.after(() => service.close());
+
+ const target = await service.createCollaborationConnectionTarget();
+ assert.deepEqual(target, {
+ name: target.name,
+ transport: { kind: 'libp2p-direct', ...livePeer },
+ });
+});
+
test('revokes the one Local sharing authority without changing peer connectivity', async (t) => {
const base = await mkdtemp(join(tmpdir(), 'maka-local-shared-access-revoke-'));
t.after(() => rm(base, { recursive: true, force: true }));
diff --git a/apps/desktop/src/main/__tests__/runtime-host-profile-service.test.ts b/apps/desktop/src/main/__tests__/runtime-host-profile-service.test.ts
index d99b90a262..12a9886d42 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-profile-service.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-profile-service.test.ts
@@ -716,12 +716,27 @@ test("keeps a managed Direct route on the SSH profile credential authority", asy
await managedServices.save(MANAGED_PROFILE, MANAGED_SERVICE);
const startup = await resolveDesktopRuntimeHostStartup(root, { catalog });
const activated: ResolvedRuntimeHostProfile[] = [];
+ const livePeer = {
+ peerId: "12D3KooWpeer",
+ routeHints: ["/ip4/192.0.2.9/udp/44002/quic-v1"],
+ coordinationRelays: ["/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay"],
+ };
+ let exposeReadyState = false;
const service = createDesktopRuntimeHostProfileService({
clientDataRoot: root,
startup,
catalog,
managedServices,
- states: () => [connectingLocal()],
+ states: () =>
+ exposeReadyState
+ ? [
+ connectingLocal(),
+ readyWithPeerEndpoint(
+ { profile: MANAGED_PROFILE, credential: "owner-token" },
+ livePeer,
+ ),
+ ]
+ : [connectingLocal()],
enable: async (target) => {
activated.push(target);
},
@@ -755,10 +770,15 @@ test("keeps a managed Direct route on the SSH profile credential authority", asy
routeHints: ["/ip4/192.0.2.8/udp/44001/quic-v1"],
coordinationRelays: [],
});
+ exposeReadyState = true;
assert.deepEqual(
await service.resolveCollaborationConnectionTarget(MANAGED_PROFILE),
- { name: MANAGED_PROFILE.name, transport: direct.profile.transport },
+ {
+ name: MANAGED_PROFILE.name,
+ transport: { kind: "libp2p-direct", ...livePeer },
+ },
);
+ exposeReadyState = false;
assert.equal((await catalog.resolve(MANAGED_PROFILE.id)).credential, "owner-token");
const beforeRejectedRemoval = {
@@ -1602,6 +1622,27 @@ function ready(target: ResolvedRuntimeHostProfile): RuntimeHostDesktopTargetStat
};
}
+function readyWithPeerEndpoint(
+ target: ResolvedRuntimeHostProfile,
+ peerEndpoint: {
+ readonly peerId: string;
+ readonly routeHints: readonly string[];
+ readonly coordinationRelays: readonly string[];
+ },
+): RuntimeHostDesktopTargetState {
+ return {
+ epoch: `epoch-${target.profile.id}`,
+ target,
+ readiness: "ready",
+ candidate: {
+ client: {
+ hostId: target.profile.kind === "remote" ? target.profile.rootId : ROOT_ID,
+ status: async () => ({ peerEndpoint }),
+ },
+ } as never,
+ };
+}
+
function unavailable(
target: ResolvedRuntimeHostProfile,
error: Error,
diff --git a/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts b/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts
index e44732fbe7..bed0ef61e3 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts
@@ -21,8 +21,9 @@ import assert from 'node:assert/strict';
import test from 'node:test';
import type { DesktopSessionSummary } from '../../preload/bridge-contract.js';
import {
- collectRuntimeHostSessionCatalogs,
collectRuntimeHostSessionCatalogsWithCoverage,
+ reconcileRuntimeHostSessionCatalog,
+ resolveRuntimeHostSessionCatalog,
} from '../../preload/runtime-host-session-catalog.js';
function session(id: string, activityAt: number): DesktopSessionSummary {
@@ -30,13 +31,17 @@ function session(id: string, activityAt: number): DesktopSessionSummary {
}
test('keeps healthy Host catalogs when another Host rejects', async () => {
- const sessions = await collectRuntimeHostSessionCatalogs([
- Promise.resolve([session('older', 1)]),
- Promise.reject(new Error('remote unavailable')),
- Promise.resolve([session('newer', 2)]),
+ const catalog = await collectRuntimeHostSessionCatalogsWithCoverage([
+ { hostId: 'older', access: 'owner', sessions: Promise.resolve([session('older', 1)]) },
+ {
+ hostId: 'unavailable',
+ access: 'owner',
+ sessions: Promise.reject(new Error('remote unavailable')),
+ },
+ { hostId: 'newer', access: 'owner', sessions: Promise.resolve([session('newer', 2)]) },
]);
- assert.deepEqual(sessions.map(({ id }) => id), ['newer', 'older']);
+ assert.deepEqual(catalog.sessions.map(({ id }) => id), ['newer', 'older']);
});
test('reports exactly which Host catalogs are complete', async () => {
@@ -57,19 +62,85 @@ test('collapses overlapping Guest catalogs in favor of the Owner authority', asy
const owner = session('shared-session', 2);
const guest = { ...owner, shared: true as const };
- const sessions = await collectRuntimeHostSessionCatalogs([
- Promise.resolve([guest]),
- Promise.resolve([owner]),
+ const catalog = await collectRuntimeHostSessionCatalogsWithCoverage([
+ { hostId: 'shared', access: 'session_guest', sessions: Promise.resolve([guest]) },
+ { hostId: 'shared', access: 'owner', sessions: Promise.resolve([owner]) },
]);
- assert.deepEqual(sessions, [owner]);
+ assert.deepEqual(catalog.sessions, [owner]);
+});
+
+test('retains a Guest catalog row only while its Runtime Host profile remains known', () => {
+ const shared = {
+ ...session('shared-session', 2),
+ runtimeHostId: 'host-guest',
+ profileId: 'guest-profile',
+ shared: true as const,
+ };
+
+ const reconnecting = reconcileRuntimeHostSessionCatalog([shared], {
+ sessions: [],
+ completeHostIds: [],
+ knownProfileIds: ['guest-profile'],
+ });
+ assert.deepEqual(reconnecting, [shared]);
+
+ assert.deepEqual(
+ reconcileRuntimeHostSessionCatalog(reconnecting, {
+ sessions: [{ ...shared, activityAt: 3 }],
+ completeHostIds: ['host-guest'],
+ knownProfileIds: ['guest-profile'],
+ }),
+ [{ ...shared, activityAt: 3 }],
+ );
+
+ assert.deepEqual(
+ reconcileRuntimeHostSessionCatalog(reconnecting, {
+ sessions: [],
+ completeHostIds: [],
+ knownProfileIds: [],
+ }),
+ [],
+ );
+});
+
+test('keeps healthy Owner catalogs when Guest mount inventory is unavailable', async () => {
+ const owner = {
+ ...session('owner-session', 3),
+ runtimeHostId: 'owner-host',
+ profileId: 'owner-profile',
+ };
+ const shared = {
+ ...session('shared-session', 2),
+ runtimeHostId: 'guest-host',
+ profileId: 'guest-profile',
+ shared: true as const,
+ };
+
+ assert.deepEqual(
+ await resolveRuntimeHostSessionCatalog(
+ [shared],
+ Promise.resolve({ sessions: [owner], completeHostIds: ['owner-host'] }),
+ () => ['owner-profile'],
+ Promise.reject(new Error('Guest mount store is unreadable')),
+ ),
+ [owner, shared],
+ );
});
test('fails when every Host catalog rejects', async () => {
await assert.rejects(
- collectRuntimeHostSessionCatalogs([
- Promise.reject(new Error('first unavailable')),
- Promise.reject(new Error('second unavailable')),
+ collectRuntimeHostSessionCatalogsWithCoverage([
+ {
+ hostId: 'first',
+ access: 'owner',
+ sessions: Promise.reject(new Error('first unavailable')),
+ },
+ {
+ hostId: 'second',
+ access: 'owner',
+ sessions: Promise.reject(new Error('second unavailable')),
+ },
]),
/Every Runtime Host Session Catalog request failed/,
);
diff --git a/apps/desktop/src/main/__tests__/runtime-host-turn-request-inbox-preload.test.ts b/apps/desktop/src/main/__tests__/runtime-host-turn-request-inbox-preload.test.ts
new file mode 100644
index 0000000000..267504c866
--- /dev/null
+++ b/apps/desktop/src/main/__tests__/runtime-host-turn-request-inbox-preload.test.ts
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { SessionTurnAccessRequest } from '@maka/runtime-host/protocol';
+import { collectAvailablePendingTurnRequests } from '../../preload/runtime-host-turn-request-inbox.js';
+
+function request(requestId: string, createdAt: string): SessionTurnAccessRequest {
+ return { requestId, createdAt } as SessionTurnAccessRequest;
+}
+
+test('keeps available collaboration inboxes when another Owner Host rejects', async () => {
+ const requests = await collectAvailablePendingTurnRequests([
+ Promise.reject(new Error('Local Host does not expose collaboration authority')),
+ Promise.resolve([
+ request('later', '2026-09-01T00:00:02.000Z'),
+ request('earlier', '2026-09-01T00:00:01.000Z'),
+ ]),
+ ]);
+
+ assert.deepEqual(requests.map(({ requestId }) => requestId), ['earlier', 'later']);
+});
+
+test('retains the previous inbox projection when every Owner Host rejects', async () => {
+ await assert.rejects(
+ collectAvailablePendingTurnRequests([
+ Promise.reject(new Error('first unavailable')),
+ Promise.reject(new Error('second unavailable')),
+ ]),
+ /Every Runtime Host collaboration inbox request failed/,
+ );
+});
diff --git a/apps/desktop/src/main/__tests__/session-turn-request-inbox-model.test.ts b/apps/desktop/src/main/__tests__/session-turn-request-inbox-model.test.ts
new file mode 100644
index 0000000000..eba12f0ea8
--- /dev/null
+++ b/apps/desktop/src/main/__tests__/session-turn-request-inbox-model.test.ts
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { SessionTurnAccessRequest } from '@maka/runtime-host/protocol';
+import {
+ groupPendingTurnRequests,
+ samePendingTurnRequests,
+ turnRequestPreview,
+ unseenTurnRequests,
+} from '../../renderer/features/session-collaboration/testing.js';
+
+test('Turn-request inbox keeps only actionable requests and detects new arrivals', () => {
+ const first = request('request-1', 'session-1', ' Review\nthis change ');
+ const second = request('request-2', 'session-1', 'Continue');
+ const decided: SessionTurnAccessRequest = {
+ ...request('request-3', 'session-2', 'Already handled'),
+ state: {
+ kind: 'rejected',
+ decidedAt: '2026-09-01T00:00:03.000Z',
+ decidedBy: 'local_owner',
+ },
+ };
+
+ assert.deepEqual([...groupPendingTurnRequests([first, decided, second])], [
+ ['session-1', [first, second]],
+ ]);
+ assert.deepEqual(unseenTurnRequests([first, second], new Set(['request-1'])), [second]);
+ assert.equal(samePendingTurnRequests([first, second], [first, second]), true);
+ assert.equal(samePendingTurnRequests([first], [second]), false);
+ assert.equal(turnRequestPreview(first.intent.content.text), 'Review this change');
+});
+
+function request(
+ requestId: string,
+ sessionId: string,
+ text: string,
+): SessionTurnAccessRequest {
+ return {
+ requestId,
+ principalId: `session_guest:${requestId}`,
+ grantId: `grant-${requestId}`,
+ intent: { sessionId, turnId: `turn-${requestId}`, content: { text } },
+ createdAt: '2026-09-01T00:00:00.000Z',
+ state: { kind: 'pending' },
+ };
+}
diff --git a/apps/desktop/src/main/runtime-host-boot.ts b/apps/desktop/src/main/runtime-host-boot.ts
index dae1a3cbd6..e1f7ab5898 100644
--- a/apps/desktop/src/main/runtime-host-boot.ts
+++ b/apps/desktop/src/main/runtime-host-boot.ts
@@ -270,6 +270,9 @@ if (runtimeHostPeerConfiguration) {
...runtimeHostPeerConfiguration,
dataRoot: join(userDataDir, 'peer-mesh'),
endpointKind: 'client',
+ onBackgroundReconcileError: (error) => {
+ console.error('[runtime-host] Peer Mesh background synchronization failed:', error);
+ },
});
runtimeHostPeerClient = runtimeHostPeerOwner.client;
runtimeHostPeerMesh = runtimeHostPeerOwner.mesh;
@@ -532,7 +535,7 @@ const runtimeHostProfileService = createDesktopRuntimeHostProfileService({
});
const guestSessionMountService = createDesktopGuestSessionMountService({
store: createGuestSessionMountStore(runtimeHostCredentialStore),
- mount: async (target, signal, onConnectionPhase) => {
+ mount: async (target, signal, onConnectionPhase, onPeerEndpoint) => {
if (target.profile.kind !== 'remote' || !target.credential) {
throw new Error('A shared Session requires a remote Guest target');
}
@@ -541,6 +544,9 @@ const guestSessionMountService = createDesktopGuestSessionMountService({
{ profile: target.profile, credential: target.credential },
signal,
onConnectionPhase,
+ (status) => {
+ if (status.peerEndpoint) onPeerEndpoint?.(status.peerEndpoint);
+ },
);
},
finalizeAccess: async (mountId, signal) => {
@@ -1603,7 +1609,11 @@ function registerPersistentClientIpc(): void {
});
registerMarkdownSaveIpc({ ipcMain, mainWindowController });
registerDesktopRuntimeHostProfileIpc(ipcMain, runtimeHostProfileService);
- registerDesktopGuestSessionMountIpc(ipcMain, guestSessionMountService);
+ registerDesktopGuestSessionMountIpc(
+ ipcMain,
+ guestSessionMountService,
+ () => clipboard.readText(),
+ );
registerClientSettingsIpc({
ipcMain,
settingsStore,
diff --git a/apps/desktop/src/main/runtime-host-client.ts b/apps/desktop/src/main/runtime-host-client.ts
index 9bc0318393..29b98597c5 100644
--- a/apps/desktop/src/main/runtime-host-client.ts
+++ b/apps/desktop/src/main/runtime-host-client.ts
@@ -84,6 +84,7 @@ import {
type MemoryQueryInput,
type MemoryQueryResult,
type GoalControlAction,
+ type HostStatusResult,
type GoalProjection,
type OperationInput,
type OperationOutput,
@@ -295,6 +296,10 @@ export class DesktopRuntimeHostClient {
return this.#connectionClosed || this.#closeTask ? 'unavailable' : 'ready';
}
+ status(): Promise<HostStatusResult> {
+ return this.connection.status();
+ }
+
finalizeAccessCredential(
timeoutMs?: number,
): Promise<OperationOutput<'access.credential.finalize'>> {
@@ -331,8 +336,11 @@ export class DesktopRuntimeHostClient {
return this.request('collaboration.turn-request.create', { intent });
}
- queryCollaborationTurnRequests(sessionId: string): Promise<CollaborationTurnRequestQueryResult> {
- return this.request('collaboration.turn-request.query', { sessionId });
+ queryCollaborationTurnRequests(sessionId?: string): Promise<CollaborationTurnRequestQueryResult> {
+ return this.request(
+ 'collaboration.turn-request.query',
+ sessionId === undefined ? {} : { sessionId },
+ );
}
acknowledgeCollaborationTurnRequest(
diff --git a/apps/desktop/src/main/runtime-host-collaboration-invitation.ts b/apps/desktop/src/main/runtime-host-collaboration-invitation.ts
index 7b9890c4fc..3137dc2d74 100644
--- a/apps/desktop/src/main/runtime-host-collaboration-invitation.ts
+++ b/apps/desktop/src/main/runtime-host-collaboration-invitation.ts
@@ -24,7 +24,7 @@ import {
import { decodeCollaborationInvitationCode } from '@maka/runtime-host/protocol';
const SCHEMA_VERSION = 1;
-const CODE_MAX_BYTES = 32 * 1024;
+export const DESKTOP_COLLABORATION_INVITATION_CODE_MAX_BYTES = 32 * 1024;
export interface DesktopCollaborationConnectionTarget {
readonly name: string;
@@ -54,7 +54,10 @@ export function encodeDesktopCollaborationInvitation(
export function decodeDesktopCollaborationInvitation(
code: string,
): DesktopCollaborationInvitation {
- if (!code || Buffer.byteLength(code, 'utf8') > CODE_MAX_BYTES) {
+ if (
+ !code ||
+ Buffer.byteLength(code, 'utf8') > DESKTOP_COLLABORATION_INVITATION_CODE_MAX_BYTES
+ ) {
throw new Error('Invalid Desktop collaboration invitation');
}
let value: unknown;
diff --git a/apps/desktop/src/main/runtime-host-collaboration-ipc-main.ts b/apps/desktop/src/main/runtime-host-collaboration-ipc-main.ts
index 622cb75c7a..afe90c6f66 100644
--- a/apps/desktop/src/main/runtime-host-collaboration-ipc-main.ts
+++ b/apps/desktop/src/main/runtime-host-collaboration-ipc-main.ts
@@ -70,6 +70,13 @@ export function registerRuntimeHostCollaborationIpc(
invitationCode: prepared.invitationCode,
target,
}),
+ connectivity:
+ target.transport.kind === 'libp2p-direct'
+ ? {
+ kind: 'peer' as const,
+ coordinationRelayCount: target.transport.coordinationRelays.length,
+ }
+ : { kind: 'configured' as const },
},
};
},
@@ -85,7 +92,9 @@ export function registerRuntimeHostCollaborationIpc(
ipcMain,
'session-collaboration:turn-request:query',
(_event, sessionId: unknown) =>
- client.queryCollaborationTurnRequests(requiredId(sessionId, 'Session')),
+ client.queryCollaborationTurnRequests(
+ sessionId === undefined ? undefined : requiredId(sessionId, 'Session'),
+ ),
);
ipcMain.handle(
'session-collaboration:turn-request:acknowledge',
diff --git a/apps/desktop/src/main/runtime-host-desktop-candidate.ts b/apps/desktop/src/main/runtime-host-desktop-candidate.ts
index f621beb29a..8f2d460c44 100644
--- a/apps/desktop/src/main/runtime-host-desktop-candidate.ts
+++ b/apps/desktop/src/main/runtime-host-desktop-candidate.ts
@@ -52,6 +52,7 @@ import {
import {
INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
RUNTIME_HOST_PROTOCOL_VERSION,
+ type HostStatusResult,
type WorkspaceTarget,
} from "@maka/runtime-host/protocol";
import type { AttachmentApprovalRegistry } from "./attachment-approval.js";
@@ -204,6 +205,7 @@ export interface DesktopRuntimeHostCandidateStartInput
readonly candidateLaunchBarrier?: RuntimeHostCandidateLaunchBarrier;
readonly peerClient?: RuntimeHostPeerClient;
readonly onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
readonly profileTarget?: {
readonly profile: PersistedRuntimeHostProfile;
readonly credential?: string;
@@ -440,6 +442,9 @@ async function startProfileDesktopRuntimeHostCandidate(
...(input.onConnectionPhase === undefined
? {}
: { onConnectionPhase: input.onConnectionPhase }),
+ ...(input.onHostStatus === undefined
+ ? {}
+ : { onHostStatus: input.onHostStatus }),
...(profileTarget.sshInteraction === undefined
? {}
: { sshInteraction: profileTarget.sshInteraction }),
diff --git a/apps/desktop/src/main/runtime-host-desktop-manager.ts b/apps/desktop/src/main/runtime-host-desktop-manager.ts
index 7953e0e1d8..de155eeb53 100644
--- a/apps/desktop/src/main/runtime-host-desktop-manager.ts
+++ b/apps/desktop/src/main/runtime-host-desktop-manager.ts
@@ -36,7 +36,7 @@ import {
type RuntimeHostRetirementMode,
type RuntimeHostSshInteraction,
} from '@maka/runtime-host/client';
-import type { HostRegistration } from '@maka/runtime-host/protocol';
+import type { HostRegistration, HostStatusResult } from '@maka/runtime-host/protocol';
import type { DesktopTargetSessionRef } from '../shared/runtime-host-identity.js';
import {
startDesktopRuntimeHostCandidate,
@@ -72,6 +72,7 @@ export interface RuntimeHostDesktopManager {
profileTarget: NonNullable<DesktopRuntimeHostCandidateStartInput['profileTarget']>,
signal?: AbortSignal,
onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void,
+ onHostStatus?: (status: HostStatusResult) => void,
): Promise<void>;
finalizeGuestAccess(mountId: string, signal?: AbortSignal): Promise<void>;
unmountGuest(mountId: string): Promise<void>;
@@ -503,12 +504,13 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
profileTarget: NonNullable<DesktopRuntimeHostCandidateStartInput['profileTarget']>,
signal?: AbortSignal,
onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void,
+ onHostStatus?: (status: HostStatusResult) => void,
): Promise<void> {
if (!isSessionGuestProfile(profileTarget.profile)) {
return Promise.reject(new Error('A Session Guest target is required'));
}
return this.#mutateTarget(profileTarget.profile.id, () =>
- this.#enable(profileTarget, true, signal, onConnectionPhase),
+ this.#enable(profileTarget, true, signal, onConnectionPhase, onHostStatus),
);
}
@@ -517,6 +519,7 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
allowSameRoot: boolean,
signal?: AbortSignal,
onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void,
+ onHostStatus?: (status: HostStatusResult) => void,
): Promise<void> {
signal?.throwIfAborted();
if (this.#closed) throw new Error('Desktop Runtime Host manager is closed');
@@ -547,6 +550,7 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
const target = this.#createTarget({
...withRuntimeHostTarget(this.#baseInput, profileTarget),
...(onConnectionPhase ? { onConnectionPhase } : {}),
+ ...(onHostStatus ? { onHostStatus } : {}),
});
this.#targets.set(profileId, target);
this.#publishState(target, {
diff --git a/apps/desktop/src/main/runtime-host-guest-session-mounts.ts b/apps/desktop/src/main/runtime-host-guest-session-mounts.ts
index 0b890f4872..4b9e5a97e6 100644
--- a/apps/desktop/src/main/runtime-host-guest-session-mounts.ts
+++ b/apps/desktop/src/main/runtime-host-guest-session-mounts.ts
@@ -25,7 +25,10 @@ import {
type RuntimeHostConnectionPhase,
type RuntimeHostRemoteTransport,
} from '@maka/runtime-host/client';
-import { decodeCollaborationInvitationCode } from '@maka/runtime-host/protocol';
+import {
+ decodeCollaborationInvitationCode,
+ type HostPeerEndpoint,
+} from '@maka/runtime-host/protocol';
import type { CredentialStore } from '@maka/storage/credential-store';
import type {
SessionCollaborationCancelResult,
@@ -33,7 +36,10 @@ import type {
SessionCollaborationImportResult,
SessionCollaborationMountSummary,
} from '../shared/session-collaboration.js';
-import { decodeDesktopCollaborationInvitation } from './runtime-host-collaboration-invitation.js';
+import {
+ decodeDesktopCollaborationInvitation,
+ DESKTOP_COLLABORATION_INVITATION_CODE_MAX_BYTES,
+} from './runtime-host-collaboration-invitation.js';
import { RuntimeHostPairingFinalizationInterruptedError } from './runtime-host-desktop-manager.js';
const STORE_SCHEMA_VERSION = 1;
@@ -127,6 +133,7 @@ export function createDesktopGuestSessionMountService(input: {
target: ResolvedRuntimeHostProfile,
signal: AbortSignal,
onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void,
+ onPeerEndpoint?: (endpoint: HostPeerEndpoint) => void,
) => Promise<void>;
readonly finalizeAccess: (mountId: string, signal: AbortSignal) => Promise<void>;
readonly unmount: (mountId: string) => Promise<void>;
@@ -162,6 +169,38 @@ export function createDesktopGuestSessionMountService(input: {
mounts = next;
};
+ const recordPeerEndpoint = (mount: GuestSessionMount, endpoint: HostPeerEndpoint): void => {
+ if (
+ closed ||
+ mount.transport.kind !== 'libp2p-direct' ||
+ endpoint.peerId !== mount.transport.peerId ||
+ (endpoint.routeHints.length === 0 && endpoint.coordinationRelays.length === 0)
+ ) return;
+ void mutate(async () => {
+ if (removingMounts.has(mount.mountId)) return;
+ const current = await load();
+ const retained = current.get(mount.mountId);
+ if (
+ retained?.transport.kind !== 'libp2p-direct' ||
+ retained.transport.peerId !== endpoint.peerId ||
+ (
+ sameStrings(retained.transport.routeHints, endpoint.routeHints) &&
+ sameStrings(retained.transport.coordinationRelays, endpoint.coordinationRelays)
+ )
+ ) return;
+ const updated = decodeMount({
+ ...retained,
+ transport: {
+ kind: 'libp2p-direct',
+ peerId: endpoint.peerId,
+ routeHints: endpoint.routeHints,
+ coordinationRelays: endpoint.coordinationRelays,
+ },
+ });
+ await persist(new Map(current).set(mount.mountId, updated));
+ }).catch((error: unknown) => onError(asError(error), mount));
+ };
+
const activate = async (
activation: LiveGuestActivation,
mount: GuestSessionMount,
@@ -174,7 +213,10 @@ export function createDesktopGuestSessionMountService(input: {
collaborationProgressForConnectionPhase(phase),
);
}
- });
+ }, (endpoint) => recordPeerEndpoint(mount, endpoint));
+ // waitForReady observes host.status before mount resolves. Commit that
+ // authenticated route snapshot before declaring the durable mount ready.
+ await mutationTail;
activation.controller.signal.throwIfAborted();
if (removingMounts.has(mount.mountId)) {
throw new Error('Shared Session mount was removed while connecting');
@@ -419,12 +461,14 @@ export function createDesktopGuestSessionMountService(input: {
export function registerDesktopGuestSessionMountIpc(
ipcMain: Pick<Electron.IpcMain, 'handle' | 'removeHandler'>,
service: DesktopGuestSessionMountService,
+ readClipboardText: () => string,
): () => void {
const channels = [
'session-collaboration:import',
'session-collaboration:import:cancel',
'session-collaboration:mount:list',
'session-collaboration:mount:remove',
+ 'session-collaboration:invitation:read-clipboard',
] as const;
ipcMain.handle(
channels[0],
@@ -441,6 +485,15 @@ export function registerDesktopGuestSessionMountIpc(
service.cancelImport(requireOperationId(operationIdValue)));
ipcMain.handle(channels[2], () => service.list());
ipcMain.handle(channels[3], (_event, mountId: string) => service.remove(mountId));
+ ipcMain.handle(channels[4], () => {
+ const value = readClipboardText().trim();
+ if (Buffer.byteLength(value, 'utf8') > DESKTOP_COLLABORATION_INVITATION_CODE_MAX_BYTES) {
+ throw new Error('Clipboard content is too large to be a shared Session invitation');
+ }
+ if (!value) return value;
+ decodeDesktopCollaborationInvitation(value);
+ return value;
+ });
return () => {
for (const channel of channels) ipcMain.removeHandler(channel);
};
@@ -510,6 +563,10 @@ function isPeerPathUnavailable(error: unknown): boolean {
return error.code === 'direct_path_unavailable' || error.code === 'transit_unavailable';
}
+function sameStrings(left: readonly string[], right: readonly string[]): boolean {
+ return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
function collaborationProgressForConnectionPhase(
phase: RuntimeHostConnectionPhase,
): SessionCollaborationImportPhase {
diff --git a/apps/desktop/src/main/runtime-host-local-remote-access.ts b/apps/desktop/src/main/runtime-host-local-remote-access.ts
index 4ade5c5610..3623734975 100644
--- a/apps/desktop/src/main/runtime-host-local-remote-access.ts
+++ b/apps/desktop/src/main/runtime-host-local-remote-access.ts
@@ -339,11 +339,14 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
};
const completed = await finishSetup(setup, 'request');
if (completed.kind === 'active_tasks') return completed;
+ const manager = requireManager(input.manager);
+ await manager.waitUntilReady('local');
+ const livePeer = await readLivePeer(localClient(input.manager), completed.peer);
return enabledResult(
encodeRuntimeHostOwnerConnectionCode({
name: hostName(),
rootId: completed.managed.rootId,
- transport: { kind: 'libp2p-direct', ...completed.peer },
+ transport: { kind: 'libp2p-direct', ...livePeer },
credential: completed.credential,
}),
);
@@ -515,9 +518,10 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
);
const peer = await readPeer(input.operator, managed);
if (!peer) throw new Error('Remote access is not enabled on this computer');
+ const livePeer = await readLivePeer(localClient(input.manager), peer);
return {
name: hostName(),
- transport: { kind: 'libp2p-direct' as const, ...peer },
+ transport: { kind: 'libp2p-direct' as const, ...livePeer },
};
});
@@ -968,6 +972,7 @@ async function issueConnectionCode(
peer: LocalPeerDescriptor,
client: DesktopRuntimeHostClient,
): Promise<string> {
+ const livePeer = await readLivePeer(client, peer);
const prepared = await client.request('access.credential.prepare', {
principalKind: 'remote_owner',
principalId: LOCAL_REMOTE_ACCESS_PRINCIPAL_ID,
@@ -984,11 +989,30 @@ async function issueConnectionCode(
return encodeRuntimeHostOwnerConnectionCode({
name: hostName(),
rootId,
- transport: { kind: 'libp2p-direct', ...peer },
+ transport: { kind: 'libp2p-direct', ...livePeer },
credential,
});
}
+async function readLivePeer(
+ client: DesktopRuntimeHostClient,
+ configured: LocalPeerDescriptor,
+): Promise<LocalPeerDescriptor> {
+ const endpoint = (await client.status()).peerEndpoint;
+ if (!endpoint) {
+ throw new Error('Runtime Host Direct peer is not available');
+ }
+ if (endpoint.peerId !== configured.peerId) {
+ throw new Error('Runtime Host Direct peer identity changed');
+ }
+ return requireEnabledPeer({
+ state: 'enabled',
+ peerId: endpoint.peerId,
+ routeHints: endpoint.routeHints,
+ coordinationRelays: endpoint.coordinationRelays,
+ });
+}
+
async function hasSharedAccess(
operator: DesktopRuntimeHostLocalOperator,
target: LocalServiceTarget,
diff --git a/apps/desktop/src/main/runtime-host-profile-service.ts b/apps/desktop/src/main/runtime-host-profile-service.ts
index 33bb1380f7..a310141439 100644
--- a/apps/desktop/src/main/runtime-host-profile-service.ts
+++ b/apps/desktop/src/main/runtime-host-profile-service.ts
@@ -920,23 +920,49 @@ export function createDesktopRuntimeHostProfileService(input: {
if (profile.kind !== 'remote') {
throw new Error('This Runtime Host does not expose a shareable peer endpoint');
}
- if (profile.transport.kind !== 'ssh') {
+ if (profile.transport.kind !== 'ssh' && profile.transport.kind !== 'libp2p-direct') {
return { name: profile.name, transport: profile.transport };
}
- const direct = (await catalog.read()).profiles.find(
- (candidate) => candidate.id === managedDirectPeerProfileId(profile.id),
- );
- if (
- !direct ||
- direct.kind !== 'remote' ||
- direct.rootId !== profile.rootId ||
- direct.transport.kind !== 'libp2p-direct'
- ) {
+ let configuredPeerId: string | undefined;
+ if (profile.transport.kind === 'libp2p-direct') {
+ configuredPeerId = profile.transport.peerId;
+ } else {
+ const direct = (await catalog.read()).profiles.find(
+ (candidate) => candidate.id === managedDirectPeerProfileId(profile.id),
+ );
+ if (
+ direct?.kind === 'remote' &&
+ direct.rootId === profile.rootId &&
+ direct.transport.kind === 'libp2p-direct'
+ ) {
+ configuredPeerId = direct.transport.peerId;
+ }
+ }
+ if (!configuredPeerId) {
throw new Error(
'Enable Direct peer access for this Runtime Host before sharing its Sessions',
);
}
- return { name: profile.name, transport: direct.transport };
+ const active = input.states().find((state) => state.target.profile.id === profile.id);
+ if (!active || active.readiness !== 'ready') {
+ throw new Error('Connect this Runtime Host before sharing its Sessions');
+ }
+ const endpoint = (await active.candidate.client.status()).peerEndpoint;
+ if (!endpoint) {
+ throw new Error('Runtime Host Direct peer is not available');
+ }
+ if (configuredPeerId !== endpoint.peerId) {
+ throw new Error('Runtime Host Direct peer identity changed');
+ }
+ return {
+ name: profile.name,
+ transport: {
+ kind: 'libp2p-direct' as const,
+ peerId: endpoint.peerId,
+ routeHints: endpoint.routeHints,
+ coordinationRelays: endpoint.coordinationRelays,
+ },
+ };
});
},
resolveManagedAccess(profileId) {
diff --git a/apps/desktop/src/preload/bridge-contract.d.ts b/apps/desktop/src/preload/bridge-contract.d.ts
index 2bc4ce1aad..da3dc9b7fc 100644
--- a/apps/desktop/src/preload/bridge-contract.d.ts
+++ b/apps/desktop/src/preload/bridge-contract.d.ts
@@ -345,7 +345,14 @@ export type DesktopSessionCollaborationCancelResult = SessionCollaborationCancel
export type DesktopSessionCollaborationPrepareResult =
| {
readonly kind: 'prepared';
- readonly invitation: CollaborationInvitationPrepareResult;
+ readonly invitation: CollaborationInvitationPrepareResult & {
+ readonly connectivity:
+ | {
+ readonly kind: 'peer';
+ readonly coordinationRelayCount: number;
+ }
+ | { readonly kind: 'configured' };
+ };
}
| { readonly kind: 'insecure_confirmation_required' };
@@ -749,6 +756,8 @@ export interface MakaBridge {
readonly operationId: string;
}, onProgress?: (phase: DesktopSessionCollaborationImportPhase) => void): Promise<DesktopSessionCollaborationImportResult>;
cancelImport(operationId: string): Promise<DesktopSessionCollaborationCancelResult>;
+ /** Reads only after the user invokes the invitation paste action. */
+ readInvitationClipboard(): Promise<string>;
listMounts(): Promise<readonly DesktopGuestSessionMountSummary[]>;
removeMount(mountId: string): Promise<void>;
requestTurn(
@@ -756,6 +765,8 @@ export interface MakaBridge {
input: { readonly turnId: string; readonly text: string },
): Promise<SessionTurnAccessRequest>;
getTurnRequests(sessionId: string): Promise<CollaborationTurnRequestQueryResult>;
+ /** Pending Owner decisions across every connected Owner Runtime Host. */
+ getPendingTurnRequests(): Promise<readonly SessionTurnAccessRequest[]>;
acknowledgeTurnRequest(
sessionId: string,
requestId: string,
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index c3a7726846..c462b5215b 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -121,9 +121,10 @@ import type { BotProvider } from '@maka/core/bot-chat-settings';
import type { BotOnboardingSnapshot, BotOnboardingStartInput } from '@maka/core/bot-onboarding';
import type { HealthSnapshot } from '@maka/core/health';
import {
- collectRuntimeHostSessionCatalogs,
collectRuntimeHostSessionCatalogsWithCoverage,
+ resolveRuntimeHostSessionCatalog,
} from './runtime-host-session-catalog.js';
+import { collectAvailablePendingTurnRequests } from './runtime-host-turn-request-inbox.js';
import type { ExecutionBoundaryReadModel, SandboxBoundaryResponse } from '@maka/core/sandbox-boundary';
import type { ClientCapabilityResponse } from '@maka/core/client-capability-grant';
import type {
@@ -222,6 +223,8 @@ import {
type OperationInput,
type OperationOutcome,
type OperationOutput,
+ type CollaborationTurnRequestQueryResult,
+ type SessionTurnAccessRequest,
} from '@maka/runtime-host/protocol';
import type { AgentGraphEpochDirectory } from '@maka/runtime-host/client';
import {
@@ -260,6 +263,7 @@ const runtimeHostMetadata = new Map<
}
>();
const runtimeHostSessionScopes = new Map<string, RuntimeHostScopeKey>();
+let lastDesktopSessionCatalog: DesktopSessionSummary[] = [];
const newTaskChangeListeners = new Set<() => void>();
let previousMainProcessInterruptionRead: Promise<boolean> | undefined;
@@ -894,19 +898,15 @@ async function listDesktopSessions(
) as SessionCatalogSummary[];
return sessions.map((session) => projectSessionSummary(parent.scope, session));
}
- const scopes = await runtimeHostScopeList();
- const sessions = await collectRuntimeHostSessionCatalogs(
- scopes.map(async (scope) => {
- const sessions = await ipcRenderer.invoke(
- 'sessions:list',
- scope,
- filter,
- ) as SessionCatalogSummary[];
- return sessions.map((session) => projectSessionCatalogSummary(scope, session));
- }),
+ lastDesktopSessionCatalog = await resolveRuntimeHostSessionCatalog(
+ lastDesktopSessionCatalog,
+ listDesktopSessionsWithCoverage(),
+ () => [...runtimeHostMetadata.values()].map(({ profileId }) => profileId),
+ // Unknown Guest coverage cannot suppress healthy Owner catalogs or prove
+ // that a previously observed Guest mount was removed.
+ listKnownGuestMountProfileIds(),
);
- recordSessionCatalogScopes(sessions);
- return sessions;
+ return lastDesktopSessionCatalog;
}
async function listDesktopSessionsWithCoverage(): Promise<{
@@ -931,6 +931,24 @@ async function listDesktopSessionsWithCoverage(): Promise<{
return catalog;
}
+async function listKnownGuestMountProfileIds(): Promise<string[]> {
+ const mounts: unknown = await ipcRenderer.invoke('session-collaboration:mount:list');
+ if (!Array.isArray(mounts)) {
+ throw new Error('Desktop shared Session mounts are unavailable');
+ }
+ return mounts.map((mount) => {
+ if (
+ !mount ||
+ typeof mount !== 'object' ||
+ !('mountId' in mount) ||
+ typeof mount.mountId !== 'string'
+ ) {
+ throw new Error('Desktop shared Session mount is invalid');
+ }
+ return mount.mountId;
+ });
+}
+
async function createDesktopSessionOnScope(
scope: DesktopTargetScope,
input?: CreateSessionRequestInput,
@@ -1305,6 +1323,9 @@ const makaBridge = {
cancelImport(operationId) {
return ipcRenderer.invoke('session-collaboration:import:cancel', operationId);
},
+ readInvitationClipboard() {
+ return ipcRenderer.invoke('session-collaboration:invitation:read-clipboard');
+ },
listMounts() {
return ipcRenderer.invoke('session-collaboration:mount:list');
},
@@ -1331,6 +1352,28 @@ const makaBridge = {
session.sessionId,
);
},
+ async getPendingTurnRequests() {
+ const scopes = (await runtimeHostScopeList()).filter(
+ (scope) => runtimeHostMetadataFor(scope)?.profileAccess === 'owner',
+ );
+ return collectAvailablePendingTurnRequests(
+ scopes.map(async (scope) => {
+ const result = await ipcRenderer.invoke(
+ 'session-collaboration:turn-request:query',
+ scope,
+ ) as CollaborationTurnRequestQueryResult;
+ return result.requests
+ .filter((request) => request.state.kind === 'pending')
+ .map((request): SessionTurnAccessRequest => ({
+ ...request,
+ intent: {
+ ...request.intent,
+ sessionId: recordRuntimeHostSessionScope(scope, request.intent.sessionId),
+ },
+ }));
+ }),
+ );
+ },
async acknowledgeTurnRequest(sessionId, requestId) {
const session = await runtimeHostSessionRef(sessionId);
return ipcRenderer.invoke(
diff --git a/apps/desktop/src/preload/runtime-host-session-catalog.ts b/apps/desktop/src/preload/runtime-host-session-catalog.ts
index d4755a8949..d8c5955d36 100644
--- a/apps/desktop/src/preload/runtime-host-session-catalog.ts
+++ b/apps/desktop/src/preload/runtime-host-session-catalog.ts
@@ -30,6 +30,29 @@ export interface RuntimeHostSessionCatalogCoverage {
readonly completeHostIds: string[];
}
+export interface RuntimeHostSessionCatalogSnapshot extends RuntimeHostSessionCatalogCoverage {
+ /** Profiles still retained by Desktop, including unavailable Guest mounts. */
+ readonly knownProfileIds: string[];
+}
+
+export async function resolveRuntimeHostSessionCatalog(
+ current: readonly DesktopSessionSummary[],
+ coverage: Promise<RuntimeHostSessionCatalogCoverage>,
+ knownRuntimeProfileIds: () => readonly string[],
+ guestMountProfileIds: Promise<readonly string[]>,
+): Promise<DesktopSessionSummary[]> {
+ const [snapshot, knownGuestProfileIds] = await Promise.all([
+ coverage,
+ guestMountProfileIds.catch(() =>
+ current.flatMap((session) => session.shared === true ? [session.profileId] : []),
+ ),
+ ]);
+ return reconcileRuntimeHostSessionCatalog(current, {
+ ...snapshot,
+ knownProfileIds: [...knownRuntimeProfileIds(), ...knownGuestProfileIds],
+ });
+}
+
export async function collectRuntimeHostSessionCatalogsWithCoverage(
requests: readonly RuntimeHostSessionCatalogRequest[],
): Promise<RuntimeHostSessionCatalogCoverage> {
@@ -59,18 +82,25 @@ export async function collectRuntimeHostSessionCatalogsWithCoverage(
};
}
-export async function collectRuntimeHostSessionCatalogs(
- requests: readonly Promise<DesktopSessionSummary[]>[],
-): Promise<DesktopSessionSummary[]> {
- const results = await Promise.allSettled(requests);
- const groups = results.flatMap((result) => result.status === 'fulfilled' ? [result.value] : []);
- if (requests.length > 0 && groups.length === 0) {
- throw new AggregateError(
- results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []),
- 'Every Runtime Host Session Catalog request failed',
- );
- }
- return sortSessionCatalogs(groups.flat());
+/**
+ * Commits complete Host catalogs authoritatively while retaining the last
+ * accepted rows for a Host that still exists but cannot answer this read.
+ * An explicitly removed profile is absent from knownProfileIds and therefore
+ * retires immediately; transport availability alone cannot change access.
+ */
+export function reconcileRuntimeHostSessionCatalog(
+ current: readonly DesktopSessionSummary[],
+ snapshot: RuntimeHostSessionCatalogSnapshot,
+): DesktopSessionSummary[] {
+ const completeHostIds = new Set(snapshot.completeHostIds);
+ const knownProfileIds = new Set(snapshot.knownProfileIds);
+ return sortSessionCatalogs([
+ ...snapshot.sessions,
+ ...current.filter(
+ (session) =>
+ knownProfileIds.has(session.profileId) && !completeHostIds.has(session.runtimeHostId),
+ ),
+ ]);
}
function sortSessionCatalogs(sessions: DesktopSessionSummary[]): DesktopSessionSummary[] {
diff --git a/apps/desktop/src/renderer/use-session-collaboration-dialog.ts b/apps/desktop/src/preload/runtime-host-turn-request-inbox.ts
similarity index 51%
copy from apps/desktop/src/renderer/use-session-collaboration-dialog.ts
copy to apps/desktop/src/preload/runtime-host-turn-request-inbox.ts
index 27f727f2c1..86199b9187 100644
--- a/apps/desktop/src/renderer/use-session-collaboration-dialog.ts
+++ b/apps/desktop/src/preload/runtime-host-turn-request-inbox.ts
@@ -17,20 +17,22 @@
* under the License.
*/
-import { useState } from 'react';
+import type { SessionTurnAccessRequest } from '@maka/runtime-host/protocol';
-export interface SessionCollaborationDialogTarget {
- readonly sessionId: string;
- readonly sessionName: string;
- readonly requiresRemoteAccess: boolean;
-}
-
-export function useSessionCollaborationDialog() {
- const [target, setTarget] = useState<SessionCollaborationDialogTarget>();
-
- return {
- target,
- open: setTarget,
- close: () => setTarget(undefined),
- };
+export async function collectAvailablePendingTurnRequests(
+ queries: readonly Promise<readonly SessionTurnAccessRequest[]>[],
+): Promise<SessionTurnAccessRequest[]> {
+ const results = await Promise.allSettled(queries);
+ const available = results.flatMap(
+ (result) => result.status === 'fulfilled' ? [result.value] : [],
+ );
+ if (queries.length > 0 && available.length === 0) {
+ throw new AggregateError(
+ results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []),
+ 'Every Runtime Host collaboration inbox request failed',
+ );
+ }
+ return available
+ .flat()
+ .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
}
diff --git a/apps/desktop/src/renderer/app-shell.tsx b/apps/desktop/src/renderer/app-shell.tsx
index 75a0b851ef..270e1d6b39 100644
--- a/apps/desktop/src/renderer/app-shell.tsx
+++ b/apps/desktop/src/renderer/app-shell.tsx
@@ -109,8 +109,8 @@ import {
import { useNewTaskChoice } from './use-new-task-choice';
import { SessionCollaborationDialog } from './session-collaboration-dialog';
import { SessionTurnRequestComposer } from './session-turn-request-composer.js';
+import * as SessionCollaboration from './features/session-collaboration';
import { getSessionCollaborationCopy } from './locales/session-collaboration-copy';
-import { useSessionCollaborationDialog } from './use-session-collaboration-dialog';
import { NEW_TASK_PENDING_KEY } from './pending-items';
import { parseDesktopSlashCommand } from './desktop-slash-command';
import {
@@ -242,6 +242,7 @@ type ComposerImportOwner = {
*/
const SETTLE_FALLBACK_GRACE_MS = 1000;
const FIRST_SEND_OBSERVATION_TIMEOUT_MS = 30_000;
+const { useSessionCollaborationDialog } = SessionCollaboration;
type FirstSendObservationWaiter = {
promise: Promise<void>;
resolve: () => void;
@@ -646,6 +647,7 @@ function AppShellContent({
setUiLocalePreference,
});
const shellCopy = getShellCopy(uiLocale).app;
+ const sessionCollaborationCopy = getSessionCollaborationCopy(uiLocale);
const previousInterruptionCopy =
getShellRemainingCopy(uiLocale).previousMainProcessInterruption;
const desktopConversationCopy = getDesktopConversationCopy(uiLocale);
@@ -830,13 +832,6 @@ function AppShellContent({
const activeMessageQueue = activeId ? messageQueueBySession[activeId] : undefined;
const activeMessageSubmitting = transientMessages.length > 0;
const activeDesktopSession = activeSession;
- function openSessionSharing(session: DesktopSessionSummary): void {
- sharedSessionDialog.open({
- sessionId: session.id,
- sessionName: session.name,
- requiresRemoteAccess: session.profileKind === 'local',
- });
- }
// The shell's reading of the active live turn: streaming/settled flags, the
// in-flight tool signal, and the #646 turn-wait cues, all derived from the
// semantic snapshot rather than the projection (#1985).
@@ -1654,7 +1649,7 @@ function AppShellContent({
newSessionPermissionMode: newTaskPermissionMode,
};
- const hasModalOpen = helpOpen || paletteOpen || searchModalOpen || sharedSessionDialog.target !== undefined;
+ const hasModalOpen = helpOpen || paletteOpen || searchModalOpen || sharedSessionDialog.isOpen;
const shellObscured = hasModalOpen || settingsOpen;
const contextCompactionPresentation = useMemo(
() =>
@@ -2732,6 +2727,12 @@ function AppShellContent({
reportError={showSessionError}
>
<ComposerMentionsProvider {...composerMentionsSurface}>
+ <SessionCollaboration.SessionTurnRequestInboxProvider
+ sessions={sessions}
+ toast={toastApi}
+ onOpenSession={openSession}
+ copy={sessionCollaborationCopy}
+ >
<div
className="appFrame agents-layout-root"
data-agents-page
@@ -2813,7 +2814,7 @@ function AppShellContent({
? undefined
: {
label: getSessionCollaborationCopy(uiLocale).shareAction,
- onClick: () => void openSessionSharing(activeDesktopSession),
+ onClick: () => sharedSessionDialog.openSession(activeDesktopSession),
}
}
onRenameSession={(name) => {
@@ -2861,6 +2862,7 @@ function AppShellContent({
projects={localProjects}
streamingSessionIds={streamingSessionIds}
staleSessionIds={staleSessionIds}
+ SessionBadge={SessionCollaboration.SessionTurnRequestBadge}
ports={sessionNavigationPorts}
commandsRef={sessionNavigationCommandsRef}
onExitWorkHub={exitWorkHub}
@@ -2929,6 +2931,11 @@ function AppShellContent({
hidden={navSelection.section !== 'sessions'}
composer={
<>
+ {!sharedSessionActive && activeId ? (
+ <SessionCollaboration.SessionTurnRequestApprovalForSession
+ sessionId={activeId}
+ />
+ ) : null}
{!sharedSessionActive && navSelection.section === 'sessions' &&
activeId &&
activeSessionForView &&
@@ -3274,21 +3281,11 @@ function AppShellContent({
<Goals.GoalHost />
<TaskEntryHost model={taskEntry.host} />
<RuntimeHostSshTerminalDialog />
- {sharedSessionDialog.target ? (
- <SessionCollaborationDialog
- mode="share"
- sessionId={sharedSessionDialog.target.sessionId}
- sessionName={sharedSessionDialog.target.sessionName}
- requiresRemoteAccess={sharedSessionDialog.target.requiresRemoteAccess}
- onEnableRemoteAccess={() => {
- const copy = getSessionCollaborationCopy(uiLocale);
- sharedSessionDialog.close();
- toastApi.info(copy.enableRemoteAccessTitle, copy.enableRemoteAccessBody);
- openSettingsSection('projects');
- }}
- onClose={sharedSessionDialog.close}
- />
- ) : null}
+ <SessionCollaborationDialog
+ target={sharedSessionDialog.target}
+ onOpenRemoteAccessSettings={() => openSettingsSection('projects')}
+ onClose={sharedSessionDialog.close}
+ />
<AppShellOverlays
settingsOpen={settingsOpen}
@@ -3338,6 +3335,7 @@ function AppShellContent({
onSelectedRuntimeHostProfileIdChange={setSettingsProfileId}
/>
</div>
+ </SessionCollaboration.SessionTurnRequestInboxProvider>
</ComposerMentionsProvider>
</Goals.GoalProvider>
);
diff --git a/apps/desktop/src/renderer/use-session-collaboration-dialog.ts b/apps/desktop/src/renderer/features/session-collaboration/controller/use-session-collaboration-dialog.ts
similarity index 78%
copy from apps/desktop/src/renderer/use-session-collaboration-dialog.ts
copy to apps/desktop/src/renderer/features/session-collaboration/controller/use-session-collaboration-dialog.ts
index 27f727f2c1..87de07e793 100644
--- a/apps/desktop/src/renderer/use-session-collaboration-dialog.ts
+++ b/apps/desktop/src/renderer/features/session-collaboration/controller/use-session-collaboration-dialog.ts
@@ -30,7 +30,19 @@ export function useSessionCollaborationDialog() {
return {
target,
+ isOpen: target !== undefined,
open: setTarget,
+ openSession(session: {
+ readonly id: string;
+ readonly name: string;
+ readonly profileKind: string;
+ }) {
+ setTarget({
+ sessionId: session.id,
+ sessionName: session.name,
+ requiresRemoteAccess: session.profileKind === 'local',
+ });
+ },
close: () => setTarget(undefined),
};
}
diff --git a/apps/desktop/src/renderer/features/session-collaboration/controller/use-turn-request-inbox.ts b/apps/desktop/src/renderer/features/session-collaboration/controller/use-turn-request-inbox.ts
new file mode 100644
index 0000000000..e7618ac395
--- /dev/null
+++ b/apps/desktop/src/renderer/features/session-collaboration/controller/use-turn-request-inbox.ts
@@ -0,0 +1,142 @@
+/*
+ * 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.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import type { SessionTurnAccessRequest } from '@maka/runtime-host/protocol';
+import type { ToastApi } from '@maka/ui';
+import {
+ groupPendingTurnRequests,
+ samePendingTurnRequests,
+ turnRequestPreview,
+ unseenTurnRequests,
+} from '../model/turn-request-inbox.js';
+import { useSessionCollaborationServices } from '../services-context.js';
+
+const INBOX_REFRESH_INTERVAL_MS = 2_000;
+
+export function useSessionTurnRequestInbox(input: {
+ readonly sessions: readonly { readonly id: string; readonly name: string }[];
+ readonly toast: ToastApi;
+ readonly onOpenSession: (sessionId: string) => void;
+ readonly copy: {
+ readonly sharedTask: string;
+ readonly newTurnRequestTitle: (count: number) => string;
+ readonly newTurnRequestSummary: (count: number) => string;
+ readonly reviewTurnRequest: string;
+ readonly turnRequests: string;
+ };
+}) {
+ const services = useSessionCollaborationServices();
+ const [requests, setRequests] = useState<readonly SessionTurnAccessRequest[]>([]);
+ const [workingRequestIds, setWorkingRequestIds] = useState<ReadonlySet<string>>(
+ () => new Set(),
+ );
+ const seenRequestIdsRef = useRef(new Set<string>());
+ const latestRef = useRef(input);
+ latestRef.current = input;
+
+ const applyProjection = useCallback((next: readonly SessionTurnAccessRequest[]) => {
+ const unseen = unseenTurnRequests(next, seenRequestIdsRef.current);
+ for (const request of next) seenRequestIdsRef.current.add(request.requestId);
+ setRequests((current) => samePendingTurnRequests(current, next) ? current : next);
+ if (unseen.length === 0) return;
+
+ const first = unseen[0]!;
+ const latest = latestRef.current;
+ const copy = latest.copy;
+ const sessionName = latest.sessions.find(
+ (session) => session.id === first.intent.sessionId,
+ )?.name ?? copy.sharedTask;
+ latest.toast.toast({
+ variant: 'warning',
+ title: copy.newTurnRequestTitle(unseen.length),
+ description: unseen.length === 1
+ ? `${sessionName} · ${turnRequestPreview(first.intent.content.text)}`
+ : copy.newTurnRequestSummary(unseen.length),
+ duration: 10_000,
+ action: {
+ label: copy.reviewTurnRequest,
+ onClick: () => latest.onOpenSession(first.intent.sessionId),
+ },
+ });
+ }, []);
+
+ const refresh = useCallback(async () => {
+ const next = await services.getPendingTurnRequests();
+ applyProjection(next);
+ }, [applyProjection, services]);
+
+ useEffect(() => {
+ let disposed = false;
+ let timer: number | undefined;
+ const poll = async () => {
+ try {
+ const next = await services.getPendingTurnRequests();
+ if (!disposed) applyProjection(next);
+ } catch {
+ // Keep the last durable projection while a Host reconnects and retry.
+ } finally {
+ if (!disposed) timer = window.setTimeout(() => void poll(), INBOX_REFRESH_INTERVAL_MS);
+ }
+ };
+ void poll();
+ return () => {
+ disposed = true;
+ if (timer !== undefined) window.clearTimeout(timer);
+ };
+ }, [applyProjection, services]);
+
+ const decide = useCallback(async (
+ request: SessionTurnAccessRequest,
+ decision: 'approve' | 'reject',
+ ) => {
+ setWorkingRequestIds((current) => new Set(current).add(request.requestId));
+ try {
+ await services.decideTurnRequest(
+ request.intent.sessionId,
+ request.requestId,
+ decision,
+ );
+ setRequests((current) => current.filter(
+ (candidate) => candidate.requestId !== request.requestId,
+ ));
+ await refresh();
+ } catch (error) {
+ const copy = latestRef.current.copy;
+ latestRef.current.toast.error(copy.turnRequests, errorMessage(error));
+ } finally {
+ setWorkingRequestIds((current) => {
+ const next = new Set(current);
+ next.delete(request.requestId);
+ return next;
+ });
+ }
+ }, [refresh]);
+
+ return {
+ requests,
+ requestsBySession: useMemo(() => groupPendingTurnRequests(requests), [requests]),
+ workingRequestIds,
+ decide,
+ };
+}
+
+function errorMessage(error: unknown): string {
+ return error instanceof Error ? error.message : String(error);
+}
diff --git a/apps/desktop/src/renderer/features/session-collaboration/index.ts b/apps/desktop/src/renderer/features/session-collaboration/index.ts
index d5c0973e3e..5ffb61409b 100644
--- a/apps/desktop/src/renderer/features/session-collaboration/index.ts
+++ b/apps/desktop/src/renderer/features/session-collaboration/index.ts
@@ -18,5 +18,9 @@
*/
export { SessionCollaborationServicesProvider } from './services-context';
+export { useSessionCollaborationDialog } from './controller/use-session-collaboration-dialog';
export { SessionCollaborationJoinDialog } from './ui/session-collaboration-join-dialog';
+export { SessionTurnRequestApprovalForSession } from './ui/session-turn-request-approval';
+export { SessionTurnRequestBadge } from './ui/session-turn-request-badge';
+export { SessionTurnRequestInboxProvider } from './turn-request-inbox-context';
export type { SessionCollaborationServices } from './ports';
diff --git a/apps/desktop/src/renderer/features/session-collaboration/model/turn-request-inbox.ts b/apps/desktop/src/renderer/features/session-collaboration/model/turn-request-inbox.ts
new file mode 100644
index 0000000000..387297f4ff
--- /dev/null
+++ b/apps/desktop/src/renderer/features/session-collaboration/model/turn-request-inbox.ts
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+import type { SessionTurnAccessRequest } from '@maka/runtime-host/protocol';
+
+export function groupPendingTurnRequests(
+ requests: readonly SessionTurnAccessRequest[],
+): ReadonlyMap<string, readonly SessionTurnAccessRequest[]> {
+ const grouped = new Map<string, SessionTurnAccessRequest[]>();
+ for (const request of requests) {
+ if (request.state.kind !== 'pending') continue;
+ const sessionId = request.intent.sessionId;
+ const sessionRequests = grouped.get(sessionId) ?? [];
+ sessionRequests.push(request);
+ grouped.set(sessionId, sessionRequests);
+ }
+ return grouped;
+}
+
+export function unseenTurnRequests(
+ requests: readonly SessionTurnAccessRequest[],
+ seenRequestIds: ReadonlySet<string>,
+): readonly SessionTurnAccessRequest[] {
+ return requests.filter(
+ (request) => request.state.kind === 'pending' && !seenRequestIds.has(request.requestId),
+ );
+}
+
+export function samePendingTurnRequests(
+ left: readonly SessionTurnAccessRequest[],
+ right: readonly SessionTurnAccessRequest[],
+): boolean {
+ return left.length === right.length && left.every((request, index) => {
+ const candidate = right[index];
+ return candidate !== undefined &&
+ request.requestId === candidate.requestId &&
+ request.intent.sessionId === candidate.intent.sessionId &&
+ request.intent.content.text === candidate.intent.content.text;
+ });
+}
+
+export function turnRequestPreview(text: string, maxLength = 120): string {
+ const collapsed = text.replace(/\s+/gu, ' ').trim();
+ if (collapsed.length <= maxLength) return collapsed;
+ return `${collapsed.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
diff --git a/apps/desktop/src/renderer/features/session-collaboration/ports.ts b/apps/desktop/src/renderer/features/session-collaboration/ports.ts
index 6079577ad3..7e65b3a5ac 100644
--- a/apps/desktop/src/renderer/features/session-collaboration/ports.ts
+++ b/apps/desktop/src/renderer/features/session-collaboration/ports.ts
@@ -23,6 +23,10 @@ import type {
SessionCollaborationImportResult,
SessionCollaborationMountSummary,
} from '../../../shared/session-collaboration.js';
+import type {
+ CollaborationTurnRequestDecideResult,
+ SessionTurnAccessRequest,
+} from '@maka/runtime-host/protocol';
export type {
SessionCollaborationCancelResult,
@@ -38,7 +42,14 @@ export interface SessionCollaborationServices {
readonly operationId: string;
}, onProgress?: (phase: SessionCollaborationImportPhase) => void): Promise<SessionCollaborationImportResult>;
cancelImport(operationId: string): Promise<SessionCollaborationCancelResult>;
+ readInvitationClipboard(): Promise<string>;
listMounts(): Promise<readonly SessionCollaborationMountSummary[]>;
removeMount(mountId: string): Promise<void>;
+ getPendingTurnRequests(): Promise<readonly SessionTurnAccessRequest[]>;
+ decideTurnRequest(
+ sessionId: string,
+ requestId: string,
+ decision: 'approve' | 'reject',
+ ): Promise<CollaborationTurnRequestDecideResult>;
createOperationId(): string;
}
diff --git a/apps/desktop/src/renderer/features/session-collaboration/index.ts b/apps/desktop/src/renderer/features/session-collaboration/testing.ts
similarity index 78%
copy from apps/desktop/src/renderer/features/session-collaboration/index.ts
copy to apps/desktop/src/renderer/features/session-collaboration/testing.ts
index d5c0973e3e..a1d8da6866 100644
--- a/apps/desktop/src/renderer/features/session-collaboration/index.ts
+++ b/apps/desktop/src/renderer/features/session-collaboration/testing.ts
@@ -17,6 +17,9 @@
* under the License.
*/
-export { SessionCollaborationServicesProvider } from './services-context';
-export { SessionCollaborationJoinDialog } from './ui/session-collaboration-join-dialog';
-export type { SessionCollaborationServices } from './ports';
+export {
+ groupPendingTurnRequests,
+ samePendingTurnRequests,
+ turnRequestPreview,
+ unseenTurnRequests,
+} from './model/turn-request-inbox.js';
diff --git a/apps/desktop/src/renderer/features/session-collaboration/turn-request-inbox-context.tsx b/apps/desktop/src/renderer/features/session-collaboration/turn-request-inbox-context.tsx
new file mode 100644
index 0000000000..2b7af3eb61
--- /dev/null
+++ b/apps/desktop/src/renderer/features/session-collaboration/turn-request-inbox-context.tsx
@@ -0,0 +1,72 @@
+/*
+ * 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.
+ */
+
+import { createContext, useContext, useMemo, type ReactNode } from 'react';
+import type { ToastApi } from '@maka/ui';
+import { useSessionTurnRequestInbox } from './controller/use-turn-request-inbox.js';
+
+export interface SessionTurnRequestInboxCopy {
+ readonly sharedTask: string;
+ readonly newTurnRequestTitle: (count: number) => string;
+ readonly newTurnRequestSummary: (count: number) => string;
+ readonly reviewTurnRequest: string;
+ readonly turnRequests: string;
+ readonly ownerTurnRequestTitle: string;
+ readonly reject: string;
+ readonly approve: string;
+ readonly moreTurnRequests: (count: number) => string;
+ readonly pendingTurnRequestCount: (count: number) => string;
+}
+
+type SessionTurnRequestInbox = ReturnType<typeof useSessionTurnRequestInbox> & {
+ readonly copy: SessionTurnRequestInboxCopy;
+};
+
+const SessionTurnRequestInboxContext = createContext<SessionTurnRequestInbox | null>(null);
+
+export function SessionTurnRequestInboxProvider(props: {
+ readonly sessions: readonly { readonly id: string; readonly name: string }[];
+ readonly toast: ToastApi;
+ readonly onOpenSession: (sessionId: string) => void;
+ readonly copy: SessionTurnRequestInboxCopy;
+ readonly children?: ReactNode;
+}) {
+ const inbox = useSessionTurnRequestInbox(props);
+ const value = useMemo<SessionTurnRequestInbox>(
+ () => ({ ...inbox, copy: props.copy }),
+ [
+ inbox.decide,
+ inbox.requests,
+ inbox.requestsBySession,
+ inbox.workingRequestIds,
+ props.copy,
+ ],
+ );
+ return (
+ <SessionTurnRequestInboxContext.Provider value={value}>
+ {props.children}
+ </SessionTurnRequestInboxContext.Provider>
+ );
+}
+
+export function useSessionTurnRequestInboxContext(): SessionTurnRequestInbox {
+ const inbox = useContext(SessionTurnRequestInboxContext);
+ if (!inbox) throw new Error('SessionTurnRequestInboxProvider is missing');
+ return inbox;
+}
diff --git a/apps/desktop/src/renderer/features/session-collaboration/ui/session-collaboration-join-dialog.tsx b/apps/desktop/src/renderer/features/session-collaboration/ui/session-collaboration-join-dialog.tsx
index 414158f9ed..d047c09b2a 100644
--- a/apps/desktop/src/renderer/features/session-collaboration/ui/session-collaboration-join-dialog.tsx
+++ b/apps/desktop/src/renderer/features/session-collaboration/ui/session-collaboration-join-dialog.tsx
@@ -45,6 +45,9 @@ export interface SessionCollaborationJoinCopy {
readonly invalidCode: string;
readonly directPathUnavailable: string;
readonly code: string;
+ readonly pasteInvitation: string;
+ readonly clipboardEmpty: string;
+ readonly clipboardUnavailable: string;
readonly join: string;
readonly validatingInvitation: string;
readonly discoveringHost: string;
@@ -66,6 +69,7 @@ export function SessionCollaborationJoinDialog(props: {
const services = useSessionCollaborationServices();
const toast = useToast();
const [code, setCode] = useState('');
+ const [readingClipboard, setReadingClipboard] = useState(false);
const [mounts, setMounts] = useState<readonly SessionCollaborationMountSummary[]>([]);
const [removingMountId, setRemovingMountId] = useState<string>();
const activeOperationId = useRef<string | undefined>(undefined);
@@ -198,6 +202,27 @@ export function SessionCollaborationJoinDialog(props: {
}
}
+ async function pasteInvitation(): Promise<void> {
+ if (working || readingClipboard) return;
+ setReadingClipboard(true);
+ try {
+ const invitation = await services.readInvitationClipboard();
+ if (!open.current) return;
+ if (!invitation) {
+ toast.info(props.copy.joinTitle, props.copy.clipboardEmpty);
+ return;
+ }
+ setCode(invitation);
+ setJoinState({ kind: 'idle' });
+ } catch {
+ if (open.current) {
+ toast.error(props.copy.joinTitle, props.copy.clipboardUnavailable);
+ }
+ } finally {
+ if (open.current) setReadingClipboard(false);
+ }
+ }
+
return (
<Dialog
isOpen
@@ -235,9 +260,22 @@ export function SessionCollaborationJoinDialog(props: {
value={code}
rows={6}
hasSpellCheck={false}
- isDisabled={working}
- onChange={setCode}
+ isDisabled={working || readingClipboard}
+ onChange={(value) => {
+ setCode(value);
+ if (joinState.kind === 'failed') setJoinState({ kind: 'idle' });
+ }}
/>
+ <div className="sessionCollaborationInvitationAction">
+ <Button
+ variant="secondary"
+ size="sm"
+ label={props.copy.pasteInvitation}
+ isDisabled={working}
+ isLoading={readingClipboard}
+ onClick={() => void pasteInvitation()}
+ />
+ </div>
{mounts.length > 0 ? (
<List density="compact" hasDividers aria-label={props.copy.retainedTasks}>
{mounts.map((mount) => (
@@ -272,7 +310,7 @@ export function SessionCollaborationJoinDialog(props: {
<Button
variant="primary"
label={props.copy.join}
- isDisabled={working || !code.trim()}
+ isDisabled={working || readingClipboard || !code.trim()}
isLoading={working}
onClick={() => void join()}
/>
diff --git a/apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-approval.tsx b/apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-approval.tsx
new file mode 100644
index 0000000000..5af9737403
--- /dev/null
+++ b/apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-approval.tsx
@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+import type { SessionTurnAccessRequest } from '@maka/runtime-host/protocol';
+import { HoverCard } from '@astryxdesign/core/HoverCard';
+import { Banner, Button } from '@maka/ui';
+import {
+ useSessionTurnRequestInboxContext,
+ type SessionTurnRequestInboxCopy,
+} from '../turn-request-inbox-context.js';
+
+export function SessionTurnRequestApprovalForSession(props: { readonly sessionId: string }) {
+ const inbox = useSessionTurnRequestInboxContext();
+ return (
+ <SessionTurnRequestApproval
+ requests={inbox.requestsBySession.get(props.sessionId) ?? []}
+ workingRequestIds={inbox.workingRequestIds}
+ copy={inbox.copy}
+ onDecide={inbox.decide}
+ />
+ );
+}
+
+export function SessionTurnRequestApproval(props: {
+ readonly requests: readonly SessionTurnAccessRequest[];
+ readonly workingRequestIds: ReadonlySet<string>;
+ readonly copy: Pick<
+ SessionTurnRequestInboxCopy,
+ 'ownerTurnRequestTitle' | 'reject' | 'approve' | 'moreTurnRequests'
+ >;
+ readonly onDecide: (
+ request: SessionTurnAccessRequest,
+ decision: 'approve' | 'reject',
+ ) => void | Promise<void>;
+}) {
+ const request = props.requests[0];
+ const copy = props.copy;
+ if (!request) return null;
+ const working = props.workingRequestIds.has(request.requestId);
+ return (
+ <div className="sessionTurnRequestApproval">
+ <Banner
+ className="sessionTurnRequestApprovalBanner"
+ status="warning"
+ role="status"
+ title={copy.ownerTurnRequestTitle}
+ description={(
+ <HoverCard
+ content={(
+ <div className="sessionTurnRequestApprovalDetails">
+ {request.intent.content.text}
+ </div>
+ )}
+ label={copy.ownerTurnRequestTitle}
+ placement="above"
+ alignment="start"
+ focusTrigger="always"
+ hasHoverIndication={false}
+ >
+ <span className="sessionTurnRequestApprovalIntent" tabIndex={0}>
+ {request.intent.content.text}
+ </span>
+ </HoverCard>
+ )}
+ endContent={(
+ <div className="sessionTurnRequestApprovalActions">
+ <Button
+ variant="secondary"
+ size="sm"
+ label={copy.reject}
+ isDisabled={working}
+ onClick={() => void props.onDecide(request, 'reject')}
+ />
+ <Button
+ variant="primary"
+ size="sm"
+ label={copy.approve}
+ isDisabled={working}
+ onClick={() => void props.onDecide(request, 'approve')}
+ />
+ </div>
+ )}
+ />
+ {props.requests.length > 1 ? (
+ <span className="sessionTurnRequestApprovalMore">
+ {copy.moreTurnRequests(props.requests.length - 1)}
+ </span>
+ ) : null}
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/use-session-collaboration-dialog.ts b/apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-badge.tsx
similarity index 60%
rename from apps/desktop/src/renderer/use-session-collaboration-dialog.ts
rename to apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-badge.tsx
index 27f727f2c1..85ec054cdd 100644
--- a/apps/desktop/src/renderer/use-session-collaboration-dialog.ts
+++ b/apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-badge.tsx
@@ -17,20 +17,16 @@
* under the License.
*/
-import { useState } from 'react';
+import { Badge } from '@maka/ui';
+import { useSessionTurnRequestInboxContext } from '../turn-request-inbox-context.js';
-export interface SessionCollaborationDialogTarget {
- readonly sessionId: string;
- readonly sessionName: string;
- readonly requiresRemoteAccess: boolean;
-}
-
-export function useSessionCollaborationDialog() {
- const [target, setTarget] = useState<SessionCollaborationDialogTarget>();
-
- return {
- target,
- open: setTarget,
- close: () => setTarget(undefined),
- };
+export function SessionTurnRequestBadge(props: { readonly sessionId: string }) {
+ const inbox = useSessionTurnRequestInboxContext();
+ const count = inbox.requestsBySession.get(props.sessionId)?.length ?? 0;
+ if (count === 0) return null;
+ return (
+ <span title={inbox.copy.pendingTurnRequestCount(count)}>
+ <Badge variant="warning" label={count > 99 ? '99+' : String(count)} />
+ </span>
+ );
}
diff --git a/apps/desktop/src/renderer/features/session-navigation/ui/session-navigation-provider.tsx b/apps/desktop/src/renderer/features/session-navigation/ui/session-navigation-provider.tsx
index 61734b865c..9abab676ca 100644
--- a/apps/desktop/src/renderer/features/session-navigation/ui/session-navigation-provider.tsx
+++ b/apps/desktop/src/renderer/features/session-navigation/ui/session-navigation-provider.tsx
@@ -17,7 +17,13 @@
* under the License.
*/
-import { useLayoutEffect, useMemo, useRef, type ReactNode } from 'react';
+import {
+ useLayoutEffect,
+ useMemo,
+ useRef,
+ type ComponentType,
+ type ReactNode,
+} from 'react';
import type { ProjectRecord } from '@maka/core/project';
import type { ScheduledTask } from '@maka/core/scheduled-task';
import {
@@ -65,6 +71,7 @@ export interface SessionNavigationProviderProps extends SessionNavigationChromeI
projects: readonly ProjectRecord[];
streamingSessionIds: ReadonlySet<string>;
staleSessionIds: ReadonlySet<string>;
+ SessionBadge?: ComponentType<{ readonly sessionId: string }>;
ports: SessionNavigationPorts;
/**
* Where the shell reads the row mutations it issues from elsewhere — the
@@ -149,6 +156,11 @@ export function SessionNavigationProvider(props: SessionNavigationProviderProps)
[hasProjectActions, hasRelink],
);
+ const sessionBadge = useMemo<SessionRailData['sessionBadge']>(() => {
+ const SessionBadge = props.SessionBadge;
+ return SessionBadge ? (session) => <SessionBadge sessionId={session.id} /> : undefined;
+ }, [props.SessionBadge]);
+
const data = useMemo<SessionRailData>(
() => ({
sessions: props.rail.sessions,
@@ -159,6 +171,7 @@ export function SessionNavigationProvider(props: SessionNavigationProviderProps)
groups: controller.layout.viewMode === 'project' ? controller.selectors.groups : undefined,
groupVariant: controller.layout.viewMode,
sessionMeta: controller.selectors.sessionMeta,
+ sessionBadge,
onSelectSession: props.onSelectSession,
rowActions,
projectActions,
@@ -175,6 +188,7 @@ export function SessionNavigationProvider(props: SessionNavigationProviderProps)
props.streamingSessionIds,
props.workHubActive,
rowActions,
+ sessionBadge,
],
);
diff --git a/apps/desktop/src/renderer/locales/session-collaboration-copy.ts b/apps/desktop/src/renderer/locales/session-collaboration-copy.ts
index 1ba3fe444d..21b53b6441 100644
--- a/apps/desktop/src/renderer/locales/session-collaboration-copy.ts
+++ b/apps/desktop/src/renderer/locales/session-collaboration-copy.ts
@@ -37,6 +37,12 @@ const ZH = {
createInvitation: '创建邀请',
invitationCode: '一次性邀请码',
invitationHelp: '邀请码包含连接地址和访客凭据,不包含所有者凭据。',
+ coordinationReady: '已包含跨网络协调路径',
+ coordinationReadyBody:
+ 'Runtime Host 已取得 Relay reservation;这能提高不同网络中的设备成功建立连接的机会。',
+ coordinationUnavailable: '尚未取得 Relay reservation',
+ coordinationUnavailableBody:
+ '这枚邀请码当前只包含直接路径,不同网络中的设备可能无法连接。可稍后撤销并重新创建。',
copy: '复制邀请码',
copied: '邀请码已复制',
close: '完成',
@@ -51,6 +57,9 @@ const ZH = {
joinTitle: '加入共享任务',
joinDescription: '粘贴邀请码,建立独立的访客连接。',
code: '邀请码',
+ pasteInvitation: '粘贴邀请码',
+ clipboardEmpty: '剪贴板中没有可粘贴的邀请码。',
+ clipboardUnavailable: '剪贴板中没有有效的邀请码;请手动粘贴。',
join: '加入',
validatingInvitation: '正在验证邀请码…',
discoveringHost: '正在查找任务所在的 Runtime Host…',
@@ -84,10 +93,21 @@ const ZH = {
turnRequestBlocked: '未能开始',
turnRequestFailed: '准入失败',
dismissTurnRequest: '关闭',
+ sharedTask: '共享任务',
+ newTurnRequestTitle: (count: number) => count === 1 ? '新的轮次请求' : `${count} 个新的轮次请求`,
+ newTurnRequestSummary: (count: number) => `${count} 个轮次请求正在等待审批`,
+ reviewTurnRequest: '查看并审批',
+ ownerTurnRequestTitle: '访客请求开始新轮次',
+ moreTurnRequests: (count: number) => `还有 ${count} 个请求等待审批`,
+ pendingTurnRequestCount: (count: number) => `${count} 个待审批轮次请求`,
};
type SessionCollaborationCopy = {
- readonly [Key in keyof typeof ZH]: string;
+ readonly [Key in keyof typeof ZH]: (typeof ZH)[Key] extends (
+ ...args: infer Args
+ ) => string
+ ? (...args: Args) => string
+ : string;
};
const EN = {
@@ -109,6 +129,12 @@ const EN = {
createInvitation: 'Create invitation',
invitationCode: 'One-time invitation code',
invitationHelp: 'The code contains the connection address and Guest credential, never the Owner credential.',
+ coordinationReady: 'Cross-network coordination is included',
+ coordinationReadyBody:
+ 'The Runtime Host has obtained a Relay reservation, improving the chance that devices on different networks can connect.',
+ coordinationUnavailable: 'No Relay reservation yet',
+ coordinationUnavailableBody:
+ 'This invitation currently contains direct routes only, so devices on different networks may not connect. Revoke and recreate it later.',
copy: 'Copy invitation',
copied: 'Invitation copied',
close: 'Done',
@@ -123,6 +149,9 @@ const EN = {
joinTitle: 'Join shared task',
joinDescription: 'Paste an invitation to create an independent Guest connection.',
code: 'Invitation code',
+ pasteInvitation: 'Paste invitation',
+ clipboardEmpty: 'There is no invitation to paste from the clipboard.',
+ clipboardUnavailable: 'The clipboard does not contain a valid invitation. Paste it manually.',
join: 'Join',
validatingInvitation: 'Validating the invitation…',
discoveringHost: 'Finding the Runtime Host for this task…',
@@ -156,6 +185,13 @@ const EN = {
turnRequestBlocked: 'Could not start',
turnRequestFailed: 'Admission failed',
dismissTurnRequest: 'Dismiss',
+ sharedTask: 'Shared task',
+ newTurnRequestTitle: (count: number) => count === 1 ? 'New Turn request' : `${count} new Turn requests`,
+ newTurnRequestSummary: (count: number) => `${count} Turn requests are waiting for approval`,
+ reviewTurnRequest: 'Review',
+ ownerTurnRequestTitle: 'A Guest requested a new Turn',
+ moreTurnRequests: (count: number) => `${count} more ${count === 1 ? 'request' : 'requests'} waiting`,
+ pendingTurnRequestCount: (count: number) => `${count} pending Turn ${count === 1 ? 'request' : 'requests'}`,
} satisfies SessionCollaborationCopy;
const COPY = { zh: ZH, en: EN } satisfies UiCatalog<SessionCollaborationCopy>;
diff --git a/apps/desktop/src/renderer/platform/desktop/create-session-collaboration-services.ts b/apps/desktop/src/renderer/platform/desktop/create-session-collaboration-services.ts
index 249eec9d80..8cb25a7688 100644
--- a/apps/desktop/src/renderer/platform/desktop/create-session-collaboration-services.ts
+++ b/apps/desktop/src/renderer/platform/desktop/create-session-collaboration-services.ts
@@ -29,8 +29,12 @@ export function createDesktopSessionCollaborationServices(
importInvitation: (input, onProgress) =>
bridge.sessionCollaboration.importInvitation(input, onProgress),
cancelImport: (operationId) => bridge.sessionCollaboration.cancelImport(operationId),
+ readInvitationClipboard: () => bridge.sessionCollaboration.readInvitationClipboard(),
listMounts: () => bridge.sessionCollaboration.listMounts(),
removeMount: (mountId) => bridge.sessionCollaboration.removeMount(mountId),
+ getPendingTurnRequests: () => bridge.sessionCollaboration.getPendingTurnRequests(),
+ decideTurnRequest: (sessionId, requestId, decision) =>
+ bridge.sessionCollaboration.decideTurnRequest(sessionId, requestId, decision),
createOperationId: () => crypto.randomUUID(),
};
}
diff --git a/apps/desktop/src/renderer/session-collaboration-dialog.tsx b/apps/desktop/src/renderer/session-collaboration-dialog.tsx
index a207762c5f..c8628268ca 100644
--- a/apps/desktop/src/renderer/session-collaboration-dialog.tsx
+++ b/apps/desktop/src/renderer/session-collaboration-dialog.tsx
@@ -40,30 +40,46 @@ import { getSessionCollaborationCopy } from './locales/session-collaboration-cop
import { turnRequestStateLabel } from './session-turn-request-composer.js';
type Props = {
- readonly mode: 'share';
- readonly sessionId: string;
- readonly sessionName: string;
- readonly requiresRemoteAccess: boolean;
- readonly onEnableRemoteAccess: () => void;
+ readonly target?: {
+ readonly sessionId: string;
+ readonly sessionName: string;
+ readonly requiresRemoteAccess: boolean;
+ };
+ readonly onOpenRemoteAccessSettings: () => void;
readonly onClose: () => void;
};
+type ShareSessionDialogProps = NonNullable<Props['target']> & Omit<Props, 'target'>;
+
type CollaborationAuthorityState =
| 'loading'
| 'available'
| 'remote_access_off'
| 'unavailable';
+type PreparedInvitation = CollaborationInvitationPrepareResult & {
+ readonly connectivity:
+ | { readonly kind: 'peer'; readonly coordinationRelayCount: number }
+ | { readonly kind: 'configured' };
+};
+
export function SessionCollaborationDialog(props: Props) {
- return <ShareSessionDialog {...props} />;
+ if (!props.target) return null;
+ return (
+ <ShareSessionDialog
+ {...props.target}
+ onOpenRemoteAccessSettings={props.onOpenRemoteAccessSettings}
+ onClose={props.onClose}
+ />
+ );
}
-function ShareSessionDialog(props: Props) {
+function ShareSessionDialog(props: ShareSessionDialogProps) {
const copy = getSessionCollaborationCopy(useUiLocale());
const toast = useToast();
const [preset, setPreset] = useState<'observe' | 'request_turn'>('observe');
const [access, setAccess] = useState<CollaborationAccessQueryResult>();
- const [invitation, setInvitation] = useState<CollaborationInvitationPrepareResult>();
+ const [invitation, setInvitation] = useState<PreparedInvitation>();
const [turnRequests, setTurnRequests] = useState<readonly SessionTurnAccessRequest[]>();
const [authorityState, setAuthorityState] = useState<CollaborationAuthorityState>('loading');
const [working, setWorking] = useState(false);
@@ -133,14 +149,14 @@ function ShareSessionDialog(props: Props) {
setWorking(true);
try {
if (authorityState === 'remote_access_off') {
- props.onEnableRemoteAccess();
+ openRemoteAccessSettings();
return;
}
if (authorityState !== 'available') return;
if (props.requiresRemoteAccess) {
const access = await window.maka.localRuntimeHostRemoteAccess.getSnapshot();
if (access.state !== 'on') {
- props.onEnableRemoteAccess();
+ openRemoteAccessSettings();
return;
}
}
@@ -168,6 +184,12 @@ function ShareSessionDialog(props: Props) {
}
}
+ function openRemoteAccessSettings(): void {
+ props.onClose();
+ toast.info(copy.enableRemoteAccessTitle, copy.enableRemoteAccessBody);
+ props.onOpenRemoteAccessSettings();
+ }
+
async function copyInvitation(): Promise<void> {
if (!invitation) return;
try {
@@ -269,7 +291,21 @@ function ShareSessionDialog(props: Props) {
onChange={() => undefined}
/>
<Text type="supporting" color="secondary">{copy.invitationHelp}</Text>
- <Button variant="secondary" label={copy.copy} onClick={() => void copyInvitation()} />
+ {invitation.connectivity.kind === 'peer' ? (
+ invitation.connectivity.coordinationRelayCount > 0 ? (
+ <Banner
+ status="success"
+ title={copy.coordinationReady}
+ description={copy.coordinationReadyBody}
+ />
+ ) : (
+ <Banner
+ status="warning"
+ title={copy.coordinationUnavailable}
+ description={copy.coordinationUnavailableBody}
+ />
+ )
+ ) : null}
</FormLayout>
) : (
<Button
@@ -366,7 +402,24 @@ function ShareSessionDialog(props: Props) {
</div>
</LayoutContent>
)}
- footer={<LayoutFooter><Button variant="secondary" label={copy.close} isDisabled={working} onClick={props.onClose} /></LayoutFooter>}
+ footer={(
+ <LayoutFooter>
+ <Button
+ variant="secondary"
+ label={copy.close}
+ isDisabled={working}
+ onClick={props.onClose}
+ />
+ {invitation ? (
+ <Button
+ variant="primary"
+ label={copy.copy}
+ isDisabled={working}
+ onClick={() => void copyInvitation()}
+ />
+ ) : null}
+ </LayoutFooter>
+ )}
/>
</Dialog>
);
diff --git a/apps/desktop/src/renderer/styles/settings/runtime-host.css b/apps/desktop/src/renderer/styles/settings/runtime-host.css
index d1d28b5e58..cb19a2bb5b 100644
--- a/apps/desktop/src/renderer/styles/settings/runtime-host.css
+++ b/apps/desktop/src/renderer/styles/settings/runtime-host.css
@@ -835,6 +835,11 @@
gap: var(--space-4);
}
+.sessionCollaborationInvitationAction {
+ display: flex;
+ justify-content: flex-end;
+}
+
.sessionCollaborationDisclosure {
display: flex;
flex-direction: column;
diff --git a/apps/desktop/src/renderer/styles/shell-layout.css b/apps/desktop/src/renderer/styles/shell-layout.css
index ca810d0622..edf355a89f 100644
--- a/apps/desktop/src/renderer/styles/shell-layout.css
+++ b/apps/desktop/src/renderer/styles/shell-layout.css
@@ -584,6 +584,54 @@ dialog:modal {
background: var(--background);
}
+.sessionTurnRequestApproval {
+ display: grid;
+ gap: var(--space-1);
+ width: 100%;
+ max-width: 36rem;
+ margin-inline: auto;
+ padding: var(--space-2) var(--space-3) 0;
+ box-sizing: border-box;
+ background: var(--background);
+}
+
+.sessionTurnRequestApprovalBanner {
+ min-width: 0;
+}
+
+.sessionTurnRequestApprovalIntent {
+ display: block;
+ width: 100%;
+ max-width: 100%;
+ min-width: 0;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ cursor: help;
+}
+
+.sessionTurnRequestApprovalDetails {
+ width: min(32rem, calc(100vw - 2rem));
+ max-height: min(16rem, 50vh);
+ overflow: auto;
+ white-space: pre-wrap;
+ overscroll-behavior: contain;
+ scrollbar-gutter: stable;
+ user-select: text;
+}
+
+.sessionTurnRequestApprovalActions {
+ display: inline-flex;
+ align-items: center;
+ gap: var(--space-1);
+}
+
+.sessionTurnRequestApprovalMore {
+ color: var(--foreground-secondary);
+ font: var(--typography-caption);
+ text-align: end;
+}
+
.sessionTurnRequestComposer {
padding: var(--space-3);
}
diff --git a/apps/desktop/src/renderer/styles/sidebar.css b/apps/desktop/src/renderer/styles/sidebar.css
index e5a039a327..2e66caed60 100644
--- a/apps/desktop/src/renderer/styles/sidebar.css
+++ b/apps/desktop/src/renderer/styles/sidebar.css
@@ -357,6 +357,11 @@
max-width: 88px;
}
+.maka-session-row-attention-badge {
+ display: inline-flex;
+ flex: none;
+}
+
.maka-session-row-host-badge > span {
overflow: hidden;
max-width: 100%;
diff --git a/docs/astryx-surface-file-inventory.md b/docs/astryx-surface-file-inventory.md
index 4cdf6cfa2b..2b832925c7 100644
--- a/docs/astryx-surface-file-inventory.md
+++ b/docs/astryx-surface-file-inventory.md
@@ -6,7 +6,7 @@ Generated against `@astryxdesign/core@0.5.2` (194 component exports).
Wiki bar: Design Conventions · API Use-the-System · Theming · Container Padding.
-**Totals:** 237 files — blocker 0, reimplementation 0, polish 1, aligned 236.
+**Totals:** 240 files — blocker 0, reimplementation 0, polish 1, aligned 239.
## Exclusions (explicit)
@@ -54,7 +54,10 @@ Wiki bar: Design Conventions · API Use-the-System · Theming · Container Paddi
| `apps/desktop/src/renderer/features/runtime-host-management/ui/runtime-host-peer-mesh-dialog.tsx` | dialog-overlay | Badge, Banner, Button, Dialog, DialogHeader, HStack, Layout, LayoutContent, LayoutFooter, MoreMenu, SegmentedControl, SegmentedControlItem, Selector, Switch, Text, TextArea, TextInput, Tooltip | aligned — uses Astryx (Badge, Banner, Button, Dialog, DialogHeader, HStack, Layout, LayoutContent) | aligned |
| `apps/desktop/src/renderer/features/runtime-host-management/ui/runtime-host-profile-pairing-actions.tsx` | other | Button, MoreMenu | aligned — uses Astryx (Button, MoreMenu) | aligned |
| `apps/desktop/src/renderer/features/session-collaboration/services-context.tsx` | shell-chrome-or-panel | none | aligned — no raw controls; no Astryx JSX usage | aligned |
+| `apps/desktop/src/renderer/features/session-collaboration/turn-request-inbox-context.tsx` | shell-chrome-or-panel | none | aligned — no raw controls; no Astryx JSX usage | aligned |
| `apps/desktop/src/renderer/features/session-collaboration/ui/session-collaboration-join-dialog.tsx` | dialog-overlay | Banner, Button, Dialog, DialogHeader, FormLayout, Layout, LayoutContent, LayoutFooter, List, ListItem, TextArea | aligned — uses Astryx (Banner, Button, Dialog, DialogHeader, FormLayout, Layout, LayoutContent, LayoutFooter) | aligned |
+| `apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-approval.tsx` | shell-chrome-or-panel | Banner, Button, HoverCard | aligned — uses Astryx (Banner, Button, HoverCard) | aligned |
+| `apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-badge.tsx` | shell-chrome-or-panel | Badge | aligned — uses Astryx (Badge) | aligned |
| `apps/desktop/src/renderer/features/session-navigation/services-context.tsx` | shell-chrome-or-panel | none | aligned — no raw controls; no Astryx JSX usage | aligned |
| `apps/desktop/src/renderer/features/session-navigation/ui/session-navigation-provider.tsx` | shell-chrome-or-panel | none | aligned — no raw controls; no Astryx JSX usage | aligned |
| `apps/desktop/src/renderer/features/task-entry/services-context.tsx` | other | none | aligned — no raw controls; no Astryx JSX usage | aligned |
@@ -81,7 +84,7 @@ Wiki bar: Design Conventions · API Use-the-System · Theming · Container Paddi
| `apps/desktop/src/renderer/plan-mode-panel.tsx` | shell-chrome-or-panel | Badge, Banner, Button, Collapsible | aligned — uses Astryx (Badge, Banner, Button, Collapsible) | aligned |
| `apps/desktop/src/renderer/reference-shell.css` | styles | n/a (css) | aligned — no off-rhythm control heights flagged | aligned |
| `apps/desktop/src/renderer/remote-project-directory-dialog.tsx` | dialog-overlay | Button, Dialog, DialogHeader, DropdownMenu, DropdownMenuItem, HStack, Layout, LayoutContent, LayoutFooter, Text | aligned — uses Astryx (Button, Dialog, DialogHeader, DropdownMenu, DropdownMenuItem, HStack, Layout, LayoutContent) | aligned |
-| `apps/desktop/src/renderer/session-collaboration-dialog.tsx` | dialog-overlay | Button, Dialog, DialogHeader, FormLayout, Layout, LayoutContent, LayoutFooter, SegmentedControl, SegmentedControlItem, Text, TextArea | aligned — uses Astryx (Button, Dialog, DialogHeader, FormLayout, Layout, LayoutContent, LayoutFooter, SegmentedControl) | aligned |
+| `apps/desktop/src/renderer/session-collaboration-dialog.tsx` | dialog-overlay | Banner, Button, Dialog, DialogHeader, FormLayout, Layout, LayoutContent, LayoutFooter, SegmentedControl, SegmentedControlItem, Text, TextArea | aligned — uses Astryx (Banner, Button, Dialog, DialogHeader, FormLayout, Layout, LayoutContent, LayoutFooter) | aligned |
| `apps/desktop/src/renderer/session-turn-request-composer.tsx` | shell-chrome-or-panel | Button, Text, TextArea | aligned — uses Astryx (Button, Text, TextArea) | aligned |
| `apps/desktop/src/renderer/settings/about-settings-page.tsx` | settings-page | Badge, Banner, Button, Kbd, Link, List, ListItem | aligned — uses Astryx (Badge, Banner, Button, Kbd, Link, List, ListItem) | aligned |
| `apps/desktop/src/renderer/settings/appearance-settings-page.tsx` | settings-page | Button, Grid, HStack, NumberInput, SelectableCard, Switch, Text, VStack | aligned — uses Astryx (Button, Grid, HStack, NumberInput, SelectableCard, Switch, Text, VStack) | aligned |
diff --git a/docs/astryx-surface-file-inventory.paths b/docs/astryx-surface-file-inventory.paths
index d699489cd9..398cd565ec 100644
--- a/docs/astryx-surface-file-inventory.paths
+++ b/docs/astryx-surface-file-inventory.paths
@@ -25,7 +25,10 @@ apps/desktop/src/renderer/features/runtime-host-management/ui/peer-mesh-peer-id-
apps/desktop/src/renderer/features/runtime-host-management/ui/runtime-host-peer-mesh-dialog.tsx
apps/desktop/src/renderer/features/runtime-host-management/ui/runtime-host-profile-pairing-actions.tsx
apps/desktop/src/renderer/features/session-collaboration/services-context.tsx
+apps/desktop/src/renderer/features/session-collaboration/turn-request-inbox-context.tsx
apps/desktop/src/renderer/features/session-collaboration/ui/session-collaboration-join-dialog.tsx
+apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-approval.tsx
+apps/desktop/src/renderer/features/session-collaboration/ui/session-turn-request-badge.tsx
apps/desktop/src/renderer/features/session-navigation/services-context.tsx
apps/desktop/src/renderer/features/session-navigation/ui/session-navigation-provider.tsx
apps/desktop/src/renderer/features/task-entry/services-context.tsx
diff --git a/native/runtime-host-peer/src/engine.rs b/native/runtime-host-peer/src/engine.rs
index 357901a468..7f650253f6 100644
--- a/native/runtime-host-peer/src/engine.rs
+++ b/native/runtime-host-peer/src/engine.rs
@@ -82,6 +82,7 @@ const IDLE_CONNECTION_TIMEOUT: Duration = Duration::from_secs(10);
const TARGET_COORDINATION_RESERVATIONS: usize = 2;
const MAX_AUTOMATIC_RELAY_CANDIDATES: usize = 8;
const MAX_RELAY_ADDRESSES_PER_PEER: usize = 4;
+const MAX_PUBLISHED_COORDINATION_RELAY_ADDRESSES: usize = 16;
const TRANSIT_FALLBACK_DELAY: Duration = Duration::from_secs(3);
const MAX_TRANSIT_RESERVATIONS: usize = 32;
const MAX_TRANSIT_CIRCUITS: usize = 8;
@@ -644,14 +645,12 @@ async fn run_endpoint_async(
&mut swarm,
&mut coordination_relays,
&HashMap::new(),
- false,
Instant::now(),
);
let startup_deadline = Instant::now() + Duration::from_secs(10);
let mut address_quiet_deadline = None;
let mut bound_addresses = HashSet::new();
- let mut startup_external_candidate_ready = false;
loop {
let deadline = address_quiet_deadline
.unwrap_or(startup_deadline)
@@ -668,13 +667,9 @@ async fn run_endpoint_async(
address_quiet_deadline = Some(Instant::now() + LISTENER_ADDRESS_QUIET_PERIOD);
}
}
- Ok(event) => handle_startup_event(
- &mut swarm,
- event,
- &mut coordination_relays,
- &mut startup_external_candidate_ready,
- &mut transit,
- ),
+ Ok(event) => {
+ handle_startup_event(&mut swarm, event, &mut coordination_relays, &mut transit)
+ }
Err(_) if pending_listeners.is_empty() => break,
Err(_) => {
return Err(PeerError::new(
@@ -698,7 +693,6 @@ async fn run_endpoint_async(
let (stream_completed_tx, mut stream_completed_rx) =
mpsc::channel::<CompletedStream>(MAX_ESTABLISHED_CONNECTIONS as usize);
let mut direct = DirectConnectState::default();
- let mut external_candidate_ready = startup_external_candidate_ready;
let mut deadline_tick = tokio::time::interval(Duration::from_millis(100));
deadline_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut discovered_relays = options
@@ -770,7 +764,6 @@ async fn run_endpoint_async(
&mut direct,
&coordination_relays,
&stream_control,
- external_candidate_ready,
Instant::now(),
);
start_pending_webrtc_upgrades(
@@ -831,7 +824,6 @@ async fn run_endpoint_async(
&mut direct,
&coordination_relays,
&stream_control,
- external_candidate_ready,
Instant::now(),
);
let requests = direct.pending.keys().copied().collect::<Vec<_>>();
@@ -1002,7 +994,6 @@ async fn run_endpoint_async(
&mut swarm,
&mut coordination_relays,
&direct.active,
- external_candidate_ready,
Instant::now(),
);
}
@@ -1095,7 +1086,6 @@ async fn run_endpoint_async(
&mut direct,
&coordination_relays,
&stream_control,
- external_candidate_ready,
Instant::now(),
);
maybe_open_peer_stream(
@@ -1190,7 +1180,6 @@ async fn run_endpoint_async(
&mut direct,
&coordination_relays,
&stream_control,
- external_candidate_ready,
Instant::now(),
);
maybe_open_peer_stream(
@@ -1210,7 +1199,6 @@ async fn run_endpoint_async(
event,
&mut coordination_relays,
&mut direct,
- &mut external_candidate_ready,
RouteRuntime {
active_coordination_relays: &active_coordination_relays,
transit: &mut transit,
@@ -1230,7 +1218,6 @@ async fn run_endpoint_async(
&mut swarm,
&mut coordination_relays,
&direct.active,
- external_candidate_ready,
Instant::now(),
);
let requests = direct.pending.keys().copied().collect::<Vec<_>>();
@@ -1268,7 +1255,6 @@ async fn run_endpoint_async(
&mut swarm,
&mut coordination_relays,
&direct.active,
- external_candidate_ready,
now,
);
retry_connect_routes(
@@ -1276,7 +1262,6 @@ async fn run_endpoint_async(
&mut direct,
&coordination_relays,
&stream_control,
- external_candidate_ready,
now,
);
start_pending_webrtc_upgrades(
@@ -1508,13 +1493,7 @@ fn start_connect(
referenced.insert(relay_peer),
)?;
}
- maintain_coordination_relays(
- swarm,
- coordination_relays,
- active_streams,
- false,
- Instant::now(),
- );
+ maintain_coordination_relays(swarm, coordination_relays, active_streams, Instant::now());
Ok(StartedConnect {
direct_routes: direct_targets,
coordination_relay_peers: relay_peers,
@@ -1793,7 +1772,6 @@ fn handle_swarm_event(
event: SwarmEvent<BehaviourEvent>,
coordination_relays: &mut HashMap<PeerId, CoordinationRelay>,
direct: &mut DirectConnectState,
- external_candidate_ready: &mut bool,
route_runtime: RouteRuntime<'_>,
) {
match event {
@@ -2016,13 +1994,7 @@ fn handle_swarm_event(
if let Some(relay) = coordination_relays.get_mut(&peer_id) {
relay.identify_received = true;
}
- request_coordination_reservation(
- swarm,
- coordination_relays,
- peer_id,
- *external_candidate_ready,
- Instant::now(),
- );
+ request_coordination_reservation(swarm, coordination_relays, peer_id, Instant::now());
}
SwarmEvent::Behaviour(BehaviourEvent::Identify(identify::Event::Sent {
peer_id, ..
@@ -2030,25 +2002,7 @@ fn handle_swarm_event(
if let Some(relay) = coordination_relays.get_mut(&peer_id) {
relay.identify_sent = true;
}
- request_coordination_reservation(
- swarm,
- coordination_relays,
- peer_id,
- *external_candidate_ready,
- Instant::now(),
- );
- }
- SwarmEvent::NewExternalAddrCandidate { .. } => {
- *external_candidate_ready = true;
- for peer_id in coordination_relays.keys().copied().collect::<Vec<_>>() {
- request_coordination_reservation(
- swarm,
- coordination_relays,
- peer_id,
- true,
- Instant::now(),
- );
- }
+ request_coordination_reservation(swarm, coordination_relays, peer_id, Instant::now());
}
SwarmEvent::ListenerClosed {
listener_id,
@@ -2093,7 +2047,6 @@ fn handle_startup_event(
swarm: &mut Swarm<Behaviour>,
event: SwarmEvent<BehaviourEvent>,
coordination_relays: &mut HashMap<PeerId, CoordinationRelay>,
- external_candidate_ready: &mut bool,
transit: &mut TransitRuntime,
) {
handle_swarm_event(
@@ -2101,7 +2054,6 @@ fn handle_startup_event(
event,
coordination_relays,
&mut DirectConnectState::default(),
- external_candidate_ready,
RouteRuntime {
active_coordination_relays: &Arc::new(RwLock::new(Vec::new())),
transit,
@@ -2405,7 +2357,7 @@ fn reconcile_transit_reservations(
}
relay.direct_connection_addresses.clear();
}
- maintain_coordination_relays(swarm, relays, active_streams, true, Instant::now());
+ maintain_coordination_relays(swarm, relays, active_streams, Instant::now());
}
fn retained_transit_candidates(
@@ -2600,13 +2552,38 @@ fn publish_active_coordination_relays(
relays: &HashMap<PeerId, CoordinationRelay>,
snapshot: &Arc<RwLock<Vec<Multiaddr>>>,
) {
- let mut addresses = relays
- .values()
- .filter(|relay| relay.reserve && relay.reservation_accepted)
- .flat_map(|relay| relay.reservation_addresses.iter().cloned())
+ let mut relay_routes = relays
+ .iter()
+ .filter(|(_, relay)| relay.reserve && relay.reservation_accepted)
+ .map(|(peer_id, relay)| {
+ let mut routes = relay.reservation_addresses.clone();
+ routes.sort_unstable_by_key(ToString::to_string);
+ routes.dedup();
+ (peer_id.to_string(), routes)
+ })
.collect::<Vec<_>>();
- addresses.sort_unstable_by_key(ToString::to_string);
- addresses.dedup();
+ relay_routes.sort_unstable_by(|left, right| left.0.cmp(&right.0));
+
+ let mut addresses = Vec::new();
+ let mut seen = HashSet::new();
+ let route_count = relay_routes
+ .iter()
+ .map(|(_, routes)| routes.len())
+ .max()
+ .unwrap_or_default();
+ 'routes: for route_index in 0..route_count {
+ for (_, routes) in &relay_routes {
+ let Some(address) = routes.get(route_index) else {
+ continue;
+ };
+ if seen.insert(address.clone()) {
+ addresses.push(address.clone());
+ if addresses.len() == MAX_PUBLISHED_COORDINATION_RELAY_ADDRESSES {
+ break 'routes;
+ }
+ }
+ }
+ }
if let Ok(mut current) = snapshot.write() {
*current = addresses;
}
@@ -2817,7 +2794,6 @@ fn maintain_coordination_relays(
swarm: &mut Swarm<Behaviour>,
relays: &mut HashMap<PeerId, CoordinationRelay>,
active_streams: &HashMap<ConnectionId, usize>,
- external_candidate_ready: bool,
now: Instant,
) {
for peer_id in relays.keys().copied().collect::<Vec<_>>() {
@@ -2870,7 +2846,7 @@ fn maintain_coordination_relays(
}
continue;
}
- request_coordination_reservation(swarm, relays, peer_id, external_candidate_ready, now);
+ request_coordination_reservation(swarm, relays, peer_id, now);
}
}
@@ -2878,7 +2854,6 @@ fn request_coordination_reservation(
swarm: &mut Swarm<Behaviour>,
relays: &mut HashMap<PeerId, CoordinationRelay>,
peer_id: PeerId,
- external_candidate_ready: bool,
now: Instant,
) {
let Some(relay) = relays.get_mut(&peer_id) else {
@@ -2898,7 +2873,6 @@ fn request_coordination_reservation(
|| relay.reservation_listener.is_some()
|| !identified
|| (transit_provider && !directly_connected)
- || !external_candidate_ready
|| relay.next_reservation_attempt > now
{
return;
@@ -2979,7 +2953,6 @@ fn retry_connect_routes(
direct: &mut DirectConnectState,
coordination_relays: &HashMap<PeerId, CoordinationRelay>,
stream_control: &application_stream::Control,
- external_candidate_ready: bool,
now: Instant,
) {
for connect in direct.pending.values_mut() {
@@ -3011,24 +2984,11 @@ fn retry_connect_routes(
.any(|origin| *origin == DialOrigin::Coordination)
&& (connect.retry_coordination || !stream_control.has_relayed_connection(peer_id))
{
- let mut targets = Vec::new();
- for relay in &connect.coordination_relays {
- let relay_peer = coordination_relay_peer_id(relay)
- .expect("coordination relay was validated before connecting");
- if !external_candidate_ready
- || coordination_relays
- .get(&relay_peer)
- .is_none_or(|relay| !relay.identify_received || !relay.identify_sent)
- {
- continue;
- }
- targets.push(
- relay
- .clone()
- .with(Protocol::P2pCircuit)
- .with(Protocol::P2p(peer_id)),
- );
- }
+ let targets = coordination_dial_targets(
+ peer_id,
+ &connect.coordination_relays,
+ coordination_relays,
+ );
if let Some(connection_id) = dial_direct_targets(swarm, peer_id, targets) {
connect
.dials
@@ -3069,6 +3029,29 @@ fn retry_connect_routes(
}
}
+fn coordination_dial_targets(
+ peer_id: PeerId,
+ addresses: &[Multiaddr],
+ relays: &HashMap<PeerId, CoordinationRelay>,
+) -> Vec<Multiaddr> {
+ addresses
+ .iter()
+ .filter(|address| {
+ let relay_peer = coordination_relay_peer_id(address)
+ .expect("coordination relay was validated before connecting");
+ relays
+ .get(&relay_peer)
+ .is_some_and(|relay| relay.identify_received && relay.identify_sent)
+ })
+ .map(|address| {
+ address
+ .clone()
+ .with(Protocol::P2pCircuit)
+ .with(Protocol::P2p(peer_id))
+ })
+ .collect()
+}
+
fn dial_direct_targets(
swarm: &mut Swarm<Behaviour>,
peer_id: PeerId,
@@ -3121,6 +3104,36 @@ mod tests {
);
}
+ #[test]
+ fn coordination_dial_only_requires_an_identified_relay() {
+ let relay_peer_id = PeerId::random();
+ let target_peer_id = PeerId::random();
+ let relay_address: Multiaddr = format!("/ip4/203.0.113.1/tcp/4001/p2p/{relay_peer_id}")
+ .parse()
+ .expect("valid relay address");
+ let relays = HashMap::from([(
+ relay_peer_id,
+ CoordinationRelay {
+ identify_received: true,
+ identify_sent: true,
+ ..CoordinationRelay::default()
+ },
+ )]);
+
+ assert_eq!(
+ coordination_dial_targets(
+ target_peer_id,
+ std::slice::from_ref(&relay_address),
+ &relays,
+ ),
+ vec![
+ relay_address
+ .with(Protocol::P2pCircuit)
+ .with(Protocol::P2p(target_peer_id))
+ ],
+ );
+ }
+
#[test]
fn completion_at_the_immutable_deadline_cannot_commit() {
let now = Instant::now();
@@ -3944,6 +3957,49 @@ mod tests {
);
}
+ #[test]
+ fn active_coordination_routes_respect_the_shared_route_limit() {
+ let relays = (0..5)
+ .map(|relay_index| {
+ let peer_id = PeerId::random();
+ let reservation_addresses = (0..MAX_RELAY_ADDRESSES_PER_PEER)
+ .map(|route_index| {
+ format!(
+ "/ip4/192.0.2.{}/tcp/{}/p2p/{peer_id}",
+ relay_index + 1,
+ 4001 + route_index,
+ )
+ .parse()
+ .expect("valid relay address")
+ })
+ .collect();
+ (
+ peer_id,
+ CoordinationRelay {
+ reserve: true,
+ reservation_accepted: true,
+ reservation_addresses,
+ ..CoordinationRelay::default()
+ },
+ )
+ })
+ .collect::<HashMap<_, _>>();
+ let snapshot = Arc::new(RwLock::new(Vec::new()));
+
+ publish_active_coordination_relays(&relays, &snapshot);
+
+ let routes = snapshot.read().expect("read snapshot");
+ assert_eq!(routes.len(), MAX_PUBLISHED_COORDINATION_RELAY_ADDRESSES);
+ assert_eq!(
+ routes
+ .iter()
+ .map(|route| coordination_relay_peer_id(route).expect("published relay identity"))
+ .collect::<HashSet<_>>()
+ .len(),
+ relays.len(),
+ );
+ }
+
#[test]
fn coordination_relay_requires_one_terminal_peer_identity() {
let relay = PeerId::random();
diff --git a/packages/runtime-host/src/__tests__/execution-service-listeners.test.ts b/packages/runtime-host/src/__tests__/execution-service-listeners.test.ts
new file mode 100644
index 0000000000..8027a0aab7
--- /dev/null
+++ b/packages/runtime-host/src/__tests__/execution-service-listeners.test.ts
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { RuntimeHostPeerMeshOwner } from '../peer-mesh/owner.js';
+import { attachPeerOwnerCleanup } from '../server/execution-service.js';
+import type { RuntimeHostListenerSet } from '../server/listener-set.js';
+
+test('the execution service exposes relay reservations discovered after startup', async () => {
+ let coordinationRelays: readonly string[] = [];
+ let listenersClosed = false;
+ let ownerClosed = false;
+ const peerListener = {
+ peerId: '12D3KooWpeer',
+ listenAddresses: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ get coordinationRelays() {
+ return coordinationRelays;
+ },
+ };
+ const listeners: RuntimeHostListenerSet = {
+ listeners: [],
+ localEndpoint: 'local',
+ websocketEndpoints: [],
+ peerListeners: [peerListener],
+ async closeAdmission() {},
+ async cleanup() {
+ listenersClosed = true;
+ },
+ };
+ const owner = {
+ async close() {
+ ownerClosed = true;
+ },
+ } as unknown as RuntimeHostPeerMeshOwner;
+
+ const attached = attachPeerOwnerCleanup(listeners, owner);
+ assert.deepEqual(attached.peerListeners[0]?.coordinationRelays, []);
+
+ coordinationRelays = ['/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay'];
+ assert.deepEqual(attached.peerListeners[0]?.coordinationRelays, coordinationRelays);
+
+ await attached.cleanup();
+ assert.equal(listenersClosed, true);
+ assert.equal(ownerClosed, true);
+});
diff --git a/packages/runtime-host/src/__tests__/peer-listener.test.ts b/packages/runtime-host/src/__tests__/peer-listener.test.ts
index 2a5d900895..e0d40ff411 100644
--- a/packages/runtime-host/src/__tests__/peer-listener.test.ts
+++ b/packages/runtime-host/src/__tests__/peer-listener.test.ts
@@ -21,6 +21,7 @@ import assert from 'node:assert/strict';
import { setImmediate as waitForImmediate } from 'node:timers/promises';
import { test } from 'node:test';
import { createRuntimeHostPeerListener } from '../server/peer-listener.js';
+import { createRuntimeHostListenerSet } from '../server/listener-set.js';
import type { RuntimeHostPeerClient } from '../client/peer-client.js';
import type { RuntimeHostPeerNativeStream } from '../transport/peer-native.js';
@@ -122,6 +123,33 @@ test('bounds active application streams from one authenticated peer', async () =
await listener.cleanup();
});
+test('projects newly accepted coordination relays from the running peer endpoint', async () => {
+ let coordinationRelays: readonly string[] = [];
+ const peer = {
+ ...peerWith([]),
+ identity: () => ({
+ peerId: 'peer',
+ listenAddresses: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays,
+ }),
+ };
+ const listener = createRuntimeHostPeerListener(peer, {} as never, () => {});
+ const listeners = createRuntimeHostListenerSet(
+ {
+ kind: 'local_ipc',
+ endpoint: 'local',
+ closeAdmission: async () => undefined,
+ cleanup: async () => undefined,
+ },
+ [listener],
+ );
+
+ assert.deepEqual(listeners.peerListeners[0]?.coordinationRelays, []);
+ coordinationRelays = ['/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay'];
+ assert.deepEqual(listeners.peerListeners[0]?.coordinationRelays, coordinationRelays);
+ await listeners.cleanup();
+});
+
function peerWith(streams: RuntimeHostPeerNativeStream[]): RuntimeHostPeerClient {
return {
identity: () => ({ peerId: 'peer', listenAddresses: [], coordinationRelays: [] }),
@@ -140,6 +168,7 @@ function peerWith(streams: RuntimeHostPeerNativeStream[]): RuntimeHostPeerClient
maxCircuitBytes: 256 * 1024 * 1024,
}),
configureTransit: async () => undefined,
+ observeAuthenticatedRoutes: () => undefined,
connect: async () => {
throw new Error('not used');
},
diff --git a/packages/runtime-host/src/__tests__/peer-mesh.test.ts b/packages/runtime-host/src/__tests__/peer-mesh.test.ts
index bdeba658d1..be45b83810 100644
--- a/packages/runtime-host/src/__tests__/peer-mesh.test.ts
+++ b/packages/runtime-host/src/__tests__/peer-mesh.test.ts
@@ -352,6 +352,59 @@ test('reconciles changed routes, propagates removal, and recovers the verified c
}
});
+test('publishes a changed local route promptly and refreshes a live cached peer route', {
+ timeout: 10_000,
+}, async () => {
+ const root = await mkdtemp(join(tmpdir(), 'maka-peer-mesh-route-liveness-'));
+ const network = new MemoryPeerNetwork();
+ const authorityPeer = network.create('peer-a');
+ const memberBPeer = network.create('peer-b');
+ const memberCPeer = network.create('peer-c');
+ const authority = await openPeerMeshNode({
+ dataRoot: join(root, 'authority'),
+ peer: authorityPeer,
+ });
+ const memberB = await openPeerMeshNode({
+ dataRoot: join(root, 'member-b'),
+ peer: memberBPeer,
+ });
+ const memberC = await openPeerMeshNode({
+ dataRoot: join(root, 'member-c'),
+ peer: memberCPeer,
+ });
+ // Keep the observer demand-driven so its explicit prepareRoutes() call,
+ // rather than a racing background reconciliation, owns the cache refresh.
+ const serving = [authority.serve(), memberB.serve()];
+ try {
+ const mesh = await authority.create();
+ await memberB.join(await authority.invite(mesh.roster.roster.meshId));
+ await memberC.join(await authority.invite(mesh.roster.roster.meshId));
+ await memberC.reconcile();
+ assert.deepEqual(memberC.resolveRoutes('peer-b')?.routeHints, ['/memory/peer-b/p2p/peer-b']);
+
+ const movedRoute = '/memory/peer-b-restarted/p2p/peer-b';
+ const movedRelay = '/memory/relay/peer-b-restarted';
+ memberBPeer.setRouteHints([movedRoute]);
+ memberBPeer.setCoordinationRelays([movedRelay]);
+ await waitForRoutes(authority, 'peer-b', [movedRoute], [movedRelay]);
+
+ assert.deepEqual(memberC.resolveRoutes('peer-b')?.routeHints, ['/memory/peer-b/p2p/peer-b']);
+ assert.deepEqual(memberC.resolveRoutes('peer-b')?.coordinationRelays, ['/memory/relay/peer-b']);
+ await memberC.prepareRoutes('peer-b', AbortSignal.timeout(4_000));
+ assert.deepEqual(memberC.resolveRoutes('peer-b')?.routeHints, [movedRoute]);
+ assert.deepEqual(memberC.resolveRoutes('peer-b')?.coordinationRelays, [movedRelay]);
+ } finally {
+ await Promise.allSettled([authority.close(), memberB.close(), memberC.close()]);
+ await Promise.allSettled([
+ authorityPeer.close(),
+ memberBPeer.close(),
+ memberCPeer.close(),
+ ...serving,
+ ]);
+ await rm(root, { recursive: true, force: true });
+ }
+});
+
test('reconciles one selected Mesh into signed transit routes and native policy', async () => {
const root = await mkdtemp(join(tmpdir(), 'maka-peer-mesh-transit-'));
const network = new MemoryPeerNetwork();
@@ -887,6 +940,7 @@ class MemoryPeerClient implements PeerMeshTransport {
#responseDelayMs = 0;
#reachable = true;
#routeHints: readonly string[];
+ #coordinationRelays: readonly string[];
#nextConnectionBarrier:
| {
readonly started: () => void;
@@ -916,13 +970,14 @@ class MemoryPeerClient implements PeerMeshTransport {
private readonly peers: ReadonlyMap<string, MemoryPeerClient>,
) {
this.#routeHints = [`/memory/${peerId}/p2p/${peerId}`];
+ this.#coordinationRelays = [`/memory/relay/${peerId}`];
}
identity() {
return {
peerId: this.peerId,
listenAddresses: this.#routeHints,
- coordinationRelays: [`/memory/relay/${this.peerId}`],
+ coordinationRelays: this.#coordinationRelays,
} as const;
}
@@ -930,6 +985,10 @@ class MemoryPeerClient implements PeerMeshTransport {
this.#routeHints = [...routeHints];
}
+ setCoordinationRelays(coordinationRelays: readonly string[]): void {
+ this.#coordinationRelays = [...coordinationRelays];
+ }
+
setReachable(reachable: boolean): void {
this.#reachable = reachable;
}
@@ -1128,6 +1187,29 @@ async function waitForAbortable(task: Promise<void>, signal?: AbortSignal): Prom
}
}
+async function waitForRoutes(
+ node: PeerMeshNode,
+ peerId: string,
+ expectedRouteHints: readonly string[],
+ expectedCoordinationRelays: readonly string[],
+): Promise<void> {
+ const deadline = Date.now() + 4_000;
+ while (Date.now() < deadline) {
+ const routes = node.resolveRoutes(peerId);
+ if (
+ JSON.stringify(routes?.routeHints) === JSON.stringify(expectedRouteHints) &&
+ JSON.stringify(routes?.coordinationRelays) === JSON.stringify(expectedCoordinationRelays)
+ )
+ return;
+ await delay(25);
+ }
+ assert.deepEqual(node.resolveRoutes(peerId), {
+ routeHints: expectedRouteHints,
+ coordinationRelays: expectedCoordinationRelays,
+ transitRelayPeerIds: [],
+ });
+}
+
function memorySignature(peerId: string, payload: Buffer): Buffer {
return createHash('sha256').update(peerId).update(payload).digest();
}
diff --git a/packages/runtime-host/src/__tests__/peer-native.test.ts b/packages/runtime-host/src/__tests__/peer-native.test.ts
index fc12167100..1e8c2d033b 100644
--- a/packages/runtime-host/src/__tests__/peer-native.test.ts
+++ b/packages/runtime-host/src/__tests__/peer-native.test.ts
@@ -51,6 +51,7 @@ let finishMeshAccept;
const pending = new Map();
const stats = { starts: 0, closes: 0, requests: [], cancellations: [] };
let missFirstCancellation = true;
+let selfContainedRoutesPrepared = false;
const stream = { read: async () => null, write: async () => {}, close: async () => {}, abort: () => {} };
module.exports = {
stats,
@@ -72,12 +73,15 @@ module.exports = {
connect: ({ requestId, peerId, routeHints, coordinationRelays, transitRelayPeerIds }) => {
stats.requests.push({ requestId, peerId, routeHints, coordinationRelays, transitRelayPeerIds });
if (peerId === 'unreachable') return Promise.reject(Object.assign(new Error('transit_unavailable: no approved route'), { code: 'GenericFailure' }));
- if (peerId === 'ready' || peerId === 'fallback') return Promise.resolve(stream);
+ if (peerId === 'ready' || peerId === 'fallback' || peerId === 'observed' || (peerId === 'self-contained' && selfContainedRoutesPrepared)) return Promise.resolve(stream);
return new Promise((resolve, reject) => pending.set(requestId, { resolve, reject }));
},
connectMeshControl: ({ requestId, peerId, routeHints, coordinationRelays, transitRelayPeerIds }) => {
stats.requests.push({ requestId, peerId, routeHints, coordinationRelays, transitRelayPeerIds });
- if (peerId === 'ready') return Promise.resolve(stream);
+ if (peerId === 'ready' || peerId === 'self-contained') {
+ if (peerId === 'self-contained') selfContainedRoutesPrepared = true;
+ return Promise.resolve(stream);
+ }
return new Promise((resolve, reject) => pending.set(requestId, { resolve, reject }));
},
configureTransit: async () => {},
@@ -100,16 +104,22 @@ module.exports = {
`,
);
let routesPrepared = false;
- const client = createRuntimeHostPeerClient({
+ const preparedPeerIds: string[] = [];
+ let client!: ReturnType<typeof createRuntimeHostPeerClient>;
+ client = createRuntimeHostPeerClient({
nativePath,
keyPath: join(directory, 'peer.key'),
routeResolver: {
prepareRoutes: async (peerId) => {
+ preparedPeerIds.push(peerId);
routesPrepared = true;
if (peerId === 'fallback') throw new Error('Mesh refresh failed');
+ if (peerId === 'self-contained') {
+ await client.connectMeshControl(peerConnectInput(peerId));
+ }
},
- resolveRoutes: () =>
- routesPrepared
+ resolveRoutes: (peerId) =>
+ routesPrepared && peerId !== 'observed'
? {
routeHints: ['/memory/discovered'],
coordinationRelays: ['/memory/relay'],
@@ -151,6 +161,22 @@ module.exports = {
await assert.rejects(client.connect(peerConnectInput('unreachable')), (failure: unknown) => {
return failure instanceof RuntimeHostPeerError && failure.code === 'transit_unavailable';
});
+ const selfContained = client.connect({
+ ...peerConnectInput('self-contained'),
+ coordinationRelays: ['/memory/explicit-relay'],
+ });
+ await selfContained;
+ assert.equal(preparedPeerIds.includes('self-contained'), true);
+ client.observeAuthenticatedRoutes({
+ peerId: 'observed',
+ routeHints: ['/memory/fresh'],
+ coordinationRelays: ['/memory/fresh-relay'],
+ });
+ await client.connect({
+ ...peerConnectInput('observed'),
+ routeHints: ['/memory/stale'],
+ coordinationRelays: ['/memory/stale-relay'],
+ });
assert.deepEqual(native.default.stats, {
starts: 1,
closes: 0,
@@ -197,6 +223,27 @@ module.exports = {
coordinationRelays: ['/memory/relay'],
transitRelayPeerIds: ['transit-peer'],
},
+ {
+ requestId: 7,
+ peerId: 'self-contained',
+ routeHints: ['/memory/1'],
+ coordinationRelays: [],
+ transitRelayPeerIds: [],
+ },
+ {
+ requestId: 8,
+ peerId: 'self-contained',
+ routeHints: ['/memory/discovered', '/memory/1'],
+ coordinationRelays: ['/memory/relay', '/memory/explicit-relay'],
+ transitRelayPeerIds: ['transit-peer'],
+ },
+ {
+ requestId: 9,
+ peerId: 'observed',
+ routeHints: ['/memory/fresh', '/memory/stale'],
+ coordinationRelays: ['/memory/fresh-relay', '/memory/stale-relay'],
+ transitRelayPeerIds: [],
+ },
],
cancellations: [1, 1],
});
diff --git a/packages/runtime-host/src/__tests__/protocol.test.ts b/packages/runtime-host/src/__tests__/protocol.test.ts
index db9f2d70f6..3bbe698872 100644
--- a/packages/runtime-host/src/__tests__/protocol.test.ts
+++ b/packages/runtime-host/src/__tests__/protocol.test.ts
@@ -1924,6 +1924,36 @@ describe('Runtime Host bootstrap protocol', () => {
);
});
+ test('publishes a bounded live Direct peer endpoint through Host status', () => {
+ const status = {
+ hostEpoch: 'epoch-1',
+ compositionId: 'maka.interactive',
+ compositionRevision: '1',
+ state: 'ready',
+ connections: 1,
+ activeOperations: 0,
+ activeResidencies: 0,
+ peerEndpoint: {
+ peerId: '12D3KooWhost',
+ routeHints: ['/ip4/192.0.2.1/udp/41000/quic-v1'],
+ coordinationRelays: ['/dns4/relay.example/udp/443/quic-v1/p2p/12D3KooWrelay'],
+ },
+ };
+ assert.deepEqual(HOST_BOOTSTRAP_OPERATION_SPECS['host.status'].decodeOutput(status), status);
+ assert.throws(() =>
+ HOST_BOOTSTRAP_OPERATION_SPECS['host.status'].decodeOutput({
+ ...status,
+ peerEndpoint: {
+ ...status.peerEndpoint,
+ coordinationRelays: [
+ status.peerEndpoint.coordinationRelays[0],
+ status.peerEndpoint.coordinationRelays[0],
+ ],
+ },
+ }),
+ );
+ });
+
test('keeps Runtime Host logs within the diagnostics operation contract', () => {
for (let index = 0; index < 257; index += 1) {
runtimeHostLogBuffer.append('info', `entry ${index}`);
diff --git a/packages/runtime-host/src/__tests__/session-collaboration-authority.test.ts b/packages/runtime-host/src/__tests__/session-collaboration-authority.test.ts
index c94f198afb..13a3185638 100644
--- a/packages/runtime-host/src/__tests__/session-collaboration-authority.test.ts
+++ b/packages/runtime-host/src/__tests__/session-collaboration-authority.test.ts
@@ -156,6 +156,52 @@ test('Turn requests reject execution input that the Owner cannot review', () =>
);
});
+test('Owner can query one durable Turn-request inbox without exposing another Guest', async () => {
+ const directory = await mkdtemp(join(tmpdir(), 'maka-session-turn-request-inbox-'));
+ const authority = await openRuntimeHostAccessAuthority(directory);
+ try {
+ assert.deepEqual(HOST_OPERATION_SPECS['collaboration.turn-request.query'].decodeInput({}), {});
+ const firstGuest = await activateTurnGuest(authority, 'session-1');
+ const secondGuest = await activateTurnGuest(authority, 'session-2');
+ await authority.createTurnAccessRequest(firstGuest, {
+ intent: {
+ sessionId: 'session-1',
+ turnId: 'turn-1',
+ content: { text: 'First request' },
+ },
+ });
+ await authority.createTurnAccessRequest(secondGuest, {
+ intent: {
+ sessionId: 'session-2',
+ turnId: 'turn-2',
+ content: { text: 'Second request' },
+ },
+ });
+
+ assert.deepEqual(
+ authority
+ .queryTurnAccessRequests(LOCAL_OWNER, {})
+ .requests.map((request) => request.intent.sessionId),
+ ['session-1', 'session-2'],
+ );
+ assert.deepEqual(
+ authority
+ .queryTurnAccessRequests(sessionGuest(firstGuest), {})
+ .requests.map((request) => request.intent.sessionId),
+ ['session-1'],
+ );
+ assert.deepEqual(
+ authority
+ .queryTurnAccessRequests(LOCAL_OWNER, { sessionId: 'session-2' })
+ .requests.map((request) => request.intent.sessionId),
+ ['session-2'],
+ );
+ } finally {
+ await authority.close();
+ await rm(directory, { recursive: true, force: true });
+ }
+});
+
test('an approved exact Turn request survives restart and is admitted once', async () => {
const directory = await mkdtemp(join(tmpdir(), 'maka-session-turn-request-'));
let authority = await openRuntimeHostAccessAuthority(directory);
@@ -592,9 +638,12 @@ test('drain does not terminalize an in-flight admission failure', async () => {
}
});
-async function activateTurnGuest(authority: RuntimeHostAccessAuthority): Promise<string> {
+async function activateTurnGuest(
+ authority: RuntimeHostAccessAuthority,
+ sessionId = 'session-1',
+): Promise<string> {
const prepared = await authority.prepareCollaborationInvitation('root-1', {
- sessionId: 'session-1',
+ sessionId,
grantKinds: ['session_turn_request'],
});
const invitation = decodeCollaborationInvitationCode(prepared.invitationCode);
diff --git a/packages/runtime-host/src/__tests__/session-subscription-client.test.ts b/packages/runtime-host/src/__tests__/session-subscription-client.test.ts
index 6791d4d51f..7f5ba135a3 100644
--- a/packages/runtime-host/src/__tests__/session-subscription-client.test.ts
+++ b/packages/runtime-host/src/__tests__/session-subscription-client.test.ts
@@ -55,6 +55,7 @@ import {
type SessionTranscriptFragment,
type SessionTranscriptPage,
type HostFrame,
+ type HostStatusResult,
type RequestFrame,
type SubscriptionFrame,
} from '../protocol/index.js';
@@ -1275,9 +1276,48 @@ test('close stops transcript pagination after the in-flight page', async () => {
assert.equal(pageRequests, 1);
});
+test('probes an otherwise idle accepted Runtime Host connection', { timeout: 2_000 }, async () => {
+ const probed = deferred<void>();
+ const observed = deferred<HostStatusResult>();
+ await withProtocolPeer(
+ async (transport, hostEpoch, rootId) => {
+ const hello = decodeClientFrame(await transport.read(1_000));
+ assert.ok('kind' in hello && hello.kind === 'hello');
+ await writeProtocolFrame(transport, {
+ kind: 'accepted',
+ rootId,
+ hostEpoch,
+ connectionId: 'connection-idle-liveness',
+ selectedProtocol: RUNTIME_HOST_PROTOCOL_VERSION,
+ compatibilityEpoch: RUNTIME_HOST_COMPATIBILITY_EPOCH,
+ compositionId: 'maka.interactive',
+ compositionRevision: '1',
+ state: 'ready',
+ });
+ await answerStatus(transport, hostEpoch);
+ },
+ async () => {
+ const status = await observed.promise;
+ assert.equal(status.state, 'ready');
+ assert.equal(status.compositionId, 'maka.interactive');
+ await probed.promise;
+ },
+ {
+ livenessIntervalMs: 20,
+ onLivenessProbe: probed.resolve,
+ onHostStatus: observed.resolve,
+ },
+ );
+});
+
async function withProtocolPeer(
serve: (transport: FramedTransport, hostEpoch: string, rootId: string) => Promise<void>,
run: (connection: RuntimeHostConnection) => Promise<void>,
+ connectionOptions: {
+ readonly livenessIntervalMs?: number;
+ readonly onLivenessProbe?: () => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
+ } = {},
): Promise<void> {
const base = await mkdtemp(join(tmpdir(), 'maka-runtime-host-subscription-'));
const capability = await resolveStorageRoot({
@@ -1318,6 +1358,7 @@ async function withProtocolPeer(
const connected = await connectRuntimeHost({
rootPath: join(base, 'root'),
protocol: PROTOCOL,
+ ...connectionOptions,
});
assert.equal(connected.kind, 'connected');
if (connected.kind !== 'connected') return;
diff --git a/packages/runtime-host/src/client/connection.ts b/packages/runtime-host/src/client/connection.ts
index 55a1749f3f..9788c79f06 100644
--- a/packages/runtime-host/src/client/connection.ts
+++ b/packages/runtime-host/src/client/connection.ts
@@ -98,9 +98,9 @@ export interface ConnectRuntimeHostInput {
connectTimeoutMs?: number;
handshakeTimeoutMs?: number;
/**
- * Interval between liveness probes while a domain request is outstanding.
- * Injectable so tests exercise requests that outlive a probe cycle without
- * waiting the real cadence; defaults to DEFAULT_LIVENESS_INTERVAL_MS (2s).
+ * Maximum quiet interval before an end-to-end Host liveness probe.
+ * Any valid inbound frame restarts the interval. Injectable so tests can
+ * exercise the cadence without waiting the real default (2s).
*/
livenessIntervalMs?: number;
/**
@@ -111,6 +111,8 @@ export interface ConnectRuntimeHostInput {
* connection health.
*/
onLivenessProbe?: () => void;
+ /** Receives each identity-validated Host status observation. */
+ onHostStatus?: (status: HostStatusResult) => void;
}
export type RuntimeHostUnavailableReason =
@@ -164,6 +166,7 @@ export interface ConnectRemoteRuntimeHostInput {
readonly handshakeTimeoutMs?: number;
readonly livenessIntervalMs?: number;
readonly onLivenessProbe?: () => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
readonly connectionResource?: RuntimeHostConnectionResource;
}
@@ -176,6 +179,7 @@ export interface ConnectRuntimeHostMessageTransportInput {
readonly handshakeTimeoutMs?: number;
readonly livenessIntervalMs?: number;
readonly onLivenessProbe?: () => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
readonly connectionResource?: RuntimeHostConnectionResource;
readonly peerPath?: RuntimeHostPeerConnectionPath;
}
@@ -197,6 +201,7 @@ export type ConnectRemoteRuntimeHostResult =
| 'unreachable'
| 'connect_failed'
| 'handshake_failed'
+ | 'handshake_timed_out'
| 'root_mismatch'
| 'composition_mismatch';
};
@@ -354,6 +359,7 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
#terminalError: Error | undefined;
readonly #livenessIntervalMs: number;
readonly #onLivenessProbe: (() => void) | undefined;
+ readonly #onHostStatus: ((status: HostStatusResult) => void) | undefined;
constructor(
transport: RuntimeHostMessageTransport,
@@ -370,12 +376,14 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
options?: {
livenessIntervalMs?: number;
onLivenessProbe?: () => void;
+ onHostStatus?: (status: HostStatusResult) => void;
connectionResource?: RuntimeHostConnectionResource;
peerPath?: RuntimeHostPeerConnectionPath;
},
) {
this.#livenessIntervalMs = options?.livenessIntervalMs ?? DEFAULT_LIVENESS_INTERVAL_MS;
this.#onLivenessProbe = options?.onLivenessProbe;
+ this.#onHostStatus = options?.onHostStatus;
this.#transport = transport;
this.rootId = accepted.rootId;
this.hostEpoch = accepted.hostEpoch;
@@ -421,6 +429,7 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
onFailure: (error) => this.#fail(error),
});
void this.#readResponses();
+ this.#scheduleLivenessCheck();
}
request<K extends DirectRequestOperationKey>(
@@ -494,7 +503,6 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
...(isDomainRequest ? { domainState: 'queued' as const } : {}),
timer,
});
- this.#scheduleLivenessCheck();
});
const frame = {
requestId,
@@ -549,6 +557,11 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
this.#fail(error);
throw error;
}
+ try {
+ this.#onHostStatus?.(status);
+ } catch {
+ // Observation cannot control the authenticated connection it watches.
+ }
return status;
}
@@ -704,7 +717,6 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
if (retired?.operation === frame.operation) {
this.#retiredRequests.delete(frame.requestId);
this.#releaseDomainSlot(retired);
- this.#scheduleLivenessCheck();
return;
}
this.#fail(new Error('Runtime Host returned an unmatched operation response'));
@@ -716,7 +728,6 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
}
this.#pendingRequests.delete(frame.requestId);
if (pending.timer) clearTimeout(pending.timer);
- this.#scheduleLivenessCheck();
if (frame.ok) {
try {
const accepted = pending.accept(frame.result);
@@ -795,7 +806,6 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
pending.reject(
interruptedRequestError(pending.operation, 'not_dispatched', 'timeout', error),
);
- this.#scheduleLivenessCheck();
return;
}
this.#retiredRequests.set(requestId, {
@@ -803,7 +813,6 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
...(pending.domainState === 'in_flight' ? { domainState: pending.domainState } : {}),
});
pending.reject(interruptedRequestError(pending.operation, 'dispatched', 'timeout', error));
- this.#scheduleLivenessCheck();
}
#releaseDomainSlot(request: PendingRequest | RetiredRequest): void {
@@ -814,22 +823,16 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
}
#resetLivenessCheck(): void {
+ // A status observer needs periodic route observations even while other
+ // Session traffic keeps the connection active.
+ if (this.#onHostStatus) return;
if (this.#livenessTimer) clearTimeout(this.#livenessTimer);
this.#livenessTimer = undefined;
this.#scheduleLivenessCheck();
}
#scheduleLivenessCheck(): void {
- if (
- this.#terminalError ||
- this.#livenessTimer ||
- this.#livenessProbePending ||
- !this.#hasOutstandingDomainRequest()
- ) {
- if (!this.#hasOutstandingDomainRequest() && this.#livenessTimer) {
- clearTimeout(this.#livenessTimer);
- this.#livenessTimer = undefined;
- }
+ if (this.#terminalError || this.#livenessTimer || this.#livenessProbePending) {
return;
}
this.#livenessTimer = setTimeout(() => {
@@ -838,18 +841,8 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
}, this.#livenessIntervalMs);
}
- #hasOutstandingDomainRequest(): boolean {
- if (this.#retiredRequests.size > 0) return true;
- for (const pending of this.#pendingRequests.values()) {
- if (pending.operation !== 'host.status') return true;
- }
- return false;
- }
-
#startLivenessProbe(): void {
- if (this.#terminalError || this.#livenessProbePending || !this.#hasOutstandingDomainRequest()) {
- return;
- }
+ if (this.#terminalError || this.#livenessProbePending) return;
this.#livenessProbePending = true;
void this.#requestOperation(
'host.status',
@@ -1043,6 +1036,7 @@ export async function connectRemoteRuntimeHost(
handshakeTimeoutMs: normalized.handshakeTimeoutMs,
livenessIntervalMs: normalized.livenessIntervalMs,
onLivenessProbe: input.onLivenessProbe,
+ onHostStatus: input.onHostStatus,
connectionResource: input.connectionResource,
});
} catch (error) {
@@ -1056,11 +1050,13 @@ export async function connectRuntimeHostMessageTransport(
): Promise<ConnectRemoteRuntimeHostResult> {
let resourceTransferred = false;
let timer: ReturnType<typeof setTimeout> | undefined;
+ let handshakeTimedOut = false;
try {
const normalized = normalizeConnectRuntimeHostInput(input);
const compositionId = requireHostCompositionId(input.compositionId);
const expectedRootId = requireHostRootId(input.expectedRootId);
timer = setTimeout(() => {
+ handshakeTimedOut = true;
input.transport.abort(new Error('Timed out handshaking with Runtime Host'));
}, normalized.handshakeTimeoutMs);
const result = await exchangeRuntimeHostHandshake({
@@ -1071,6 +1067,7 @@ export async function connectRuntimeHostMessageTransport(
expectedRootId,
livenessIntervalMs: normalized.livenessIntervalMs,
onLivenessProbe: input.onLivenessProbe,
+ onHostStatus: input.onHostStatus,
connectionResource: input.connectionResource,
...(input.peerPath ? { peerPath: input.peerPath } : {}),
});
@@ -1088,7 +1085,10 @@ export async function connectRuntimeHostMessageTransport(
if (error instanceof RuntimeHostCompositionMismatchError) {
return { kind: 'unavailable', reason: 'composition_mismatch' };
}
- return { kind: 'unavailable', reason: 'handshake_failed' };
+ return {
+ kind: 'unavailable',
+ reason: handshakeTimedOut ? 'handshake_timed_out' : 'handshake_failed',
+ };
} finally {
if (timer) clearTimeout(timer);
if (!resourceTransferred) await input.connectionResource?.close().catch(() => undefined);
@@ -1279,6 +1279,7 @@ export async function connectResolvedRuntimeHost(
hostProtocol: { min: registration.protocolMin, max: registration.protocolMax },
livenessIntervalMs,
onLivenessProbe: input.onLivenessProbe,
+ onHostStatus: input.onHostStatus,
});
if (result.kind === 'connected') {
if (
@@ -1376,6 +1377,7 @@ interface ExchangeRuntimeHostHandshakeInput {
readonly expectedCompositionRevision?: string;
readonly livenessIntervalMs?: number;
readonly onLivenessProbe?: () => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
readonly connectionResource?: RuntimeHostConnectionResource;
readonly peerPath?: RuntimeHostPeerConnectionPath;
}
@@ -1456,6 +1458,7 @@ async function exchangeRuntimeHostHandshake(
connection: new RuntimeHostConnectionImpl(input.transport, handshake, {
livenessIntervalMs: input.livenessIntervalMs,
onLivenessProbe: input.onLivenessProbe,
+ onHostStatus: input.onHostStatus,
connectionResource: input.connectionResource,
...(input.peerPath ? { peerPath: input.peerPath } : {}),
}),
diff --git a/packages/runtime-host/src/client/host-profile.ts b/packages/runtime-host/src/client/host-profile.ts
index ea0a72ac9c..1e77cb64bb 100644
--- a/packages/runtime-host/src/client/host-profile.ts
+++ b/packages/runtime-host/src/client/host-profile.ts
@@ -27,6 +27,7 @@ import {
INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
isCanonicalRuntimeHostWebSocketPath,
RUNTIME_HOST_PROTOCOL_VERSION,
+ type HostStatusResult,
requireClientInstanceId,
requireHostRootId,
} from '../protocol/index.js';
@@ -71,6 +72,7 @@ const PROFILE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
const PEER_ID_MAX_BYTES = 160;
const PEER_ADDRESS_MAX_BYTES = 2 * 1024;
const PEER_ROUTE_MAX = 16;
+const DEFAULT_PEER_HANDSHAKE_TIMEOUT_MS = 5_000;
const PROFILE_CREDENTIAL_RECORD_PREFIX = 'maka-runtime-host-profile-credential-v1:';
const PROFILE_INCARNATION_ID_MAX_BYTES = 128;
export const RUNTIME_HOST_ACCESS_CREDENTIAL_MAX_BYTES = 8 * 1024;
@@ -382,6 +384,7 @@ export async function connectRuntimeHostProfile(
readonly sshInteraction?: RuntimeHostSshInteraction;
readonly peerClient?: RuntimeHostPeerClient;
readonly onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
},
overrides: {
connect?: typeof connectRemoteRuntimeHost;
@@ -438,6 +441,7 @@ export async function connectRemoteRuntimeHostProfile(
readonly sshInteraction?: RuntimeHostSshInteraction;
readonly peerClient?: RuntimeHostPeerClient;
readonly onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
},
overrides: {
connect?: typeof connectRemoteRuntimeHost;
@@ -466,6 +470,7 @@ export async function connectRemoteRuntimeHostProfile(
...(input.onConnectionPhase === undefined
? {}
: { onConnectionPhase: input.onConnectionPhase }),
+ ...(input.onHostStatus === undefined ? {} : { onHostStatus: input.onHostStatus }),
});
} else {
notifyConnectionPhase(input.onConnectionPhase, 'connecting');
@@ -511,6 +516,7 @@ export async function connectRemoteRuntimeHostProfile(
...(input.handshakeTimeoutMs === undefined
? {}
: { handshakeTimeoutMs: input.handshakeTimeoutMs }),
+ ...(input.onHostStatus === undefined ? {} : { onHostStatus: input.onHostStatus }),
});
try {
input.signal?.throwIfAborted();
@@ -586,8 +592,10 @@ export async function connectPeerRuntimeHost(input: {
readonly connectTimeoutMs?: number;
readonly handshakeTimeoutMs?: number;
readonly onConnectionPhase?: (phase: RuntimeHostConnectionPhase) => void;
+ readonly onHostStatus?: (status: HostStatusResult) => void;
}): Promise<RuntimeHostConnection> {
input.signal?.throwIfAborted();
+ const handshakeTimeoutMs = input.handshakeTimeoutMs ?? DEFAULT_PEER_HANDSHAKE_TIMEOUT_MS;
const stream = await input.peerClient.connect(
{
peerId: input.transport.peerId,
@@ -608,7 +616,7 @@ export async function connectPeerRuntimeHost(input: {
await writeRuntimeHostPeerAuthentication(stream, input.credential);
const authentication = await readRuntimeHostPeerAuthenticationResult(
stream,
- input.handshakeTimeoutMs,
+ handshakeTimeoutMs,
);
if (!authentication.accepted) {
throw new RuntimeHostProfileConnectionError(
@@ -628,9 +636,14 @@ export async function connectPeerRuntimeHost(input: {
max: RUNTIME_HOST_PROTOCOL_VERSION,
},
clientInstanceId: input.clientInstanceId,
- ...(input.handshakeTimeoutMs === undefined
- ? {}
- : { handshakeTimeoutMs: input.handshakeTimeoutMs }),
+ handshakeTimeoutMs,
+ onHostStatus: (status) => {
+ const endpoint = status.peerEndpoint;
+ if (endpoint?.peerId === input.transport.peerId) {
+ input.peerClient.observeAuthenticatedRoutes(endpoint);
+ }
+ input.onHostStatus?.(status);
+ },
...(stream.path ? { peerPath: stream.path } : {}),
});
input.signal?.throwIfAborted();
@@ -700,6 +713,9 @@ export function remoteRuntimeHostUnavailableError(
case 'unreachable':
message = `${subject} could not reach its endpoint`;
break;
+ case 'handshake_timed_out':
+ message = `${subject} timed out while establishing its protocol session`;
+ break;
default:
message = `${subject} is unavailable (${reason})`;
}
diff --git a/packages/runtime-host/src/client/peer-client.ts b/packages/runtime-host/src/client/peer-client.ts
index 543efdb2f0..705ba0f9fb 100644
--- a/packages/runtime-host/src/client/peer-client.ts
+++ b/packages/runtime-host/src/client/peer-client.ts
@@ -66,6 +66,11 @@ export interface RuntimeHostPeerClient {
readonly approvedRelayPeerIds: readonly string[];
readonly relayCandidates: readonly RuntimeHostPeerTransitRelayCandidate[];
}): Promise<void>;
+ observeAuthenticatedRoutes(input: {
+ readonly peerId: string;
+ readonly routeHints: readonly string[];
+ readonly coordinationRelays: readonly string[];
+ }): void;
connect(
input: RuntimeHostPeerConnectInput,
signal?: AbortSignal,
@@ -129,6 +134,13 @@ class RuntimeHostPeerClientImpl implements RuntimeHostPeerClient {
readonly #automaticRelayDiscovery: boolean;
readonly #webRtcStunUrls: readonly string[] | undefined;
readonly #routeResolver: RuntimeHostPeerRouteResolver | undefined;
+ readonly #authenticatedRoutes = new Map<
+ string,
+ Readonly<{
+ routeHints: readonly string[];
+ coordinationRelays: readonly string[];
+ }>
+ >();
#endpoint: RuntimeHostPeerNativeEndpoint | undefined;
#draining: Promise<void> | undefined;
#meshDraining: Promise<void> | undefined;
@@ -210,6 +222,21 @@ class RuntimeHostPeerClientImpl implements RuntimeHostPeerClient {
});
}
+ observeAuthenticatedRoutes(input: {
+ readonly peerId: string;
+ readonly routeHints: readonly string[];
+ readonly coordinationRelays: readonly string[];
+ }): void {
+ if (input.routeHints.length === 0 && input.coordinationRelays.length === 0) return;
+ this.#authenticatedRoutes.set(
+ input.peerId,
+ Object.freeze({
+ routeHints: Object.freeze([...input.routeHints]),
+ coordinationRelays: Object.freeze([...input.coordinationRelays]),
+ }),
+ );
+ }
+
async connect(
input: RuntimeHostPeerConnectInput,
signal?: AbortSignal,
@@ -337,13 +364,18 @@ class RuntimeHostPeerClientImpl implements RuntimeHostPeerClient {
const requestId = this.#allocateRequestId();
const discovered =
kind === 'application' ? this.#routeResolver?.resolveRoutes(input.peerId) : undefined;
+ const authenticated =
+ kind === 'application' ? this.#authenticatedRoutes.get(input.peerId) : undefined;
const connection = endpoint[kind === 'application' ? 'connect' : 'connectMeshControl']({
...input,
- routeHints: mergeAddresses(discovered?.routeHints ?? [], input.routeHints),
- coordinationRelays: mergeAddresses(
- discovered?.coordinationRelays ?? [],
- input.coordinationRelays,
- ),
+ routeHints: mergeAddresses(discovered?.routeHints ?? [], [
+ ...(authenticated?.routeHints ?? []),
+ ...input.routeHints,
+ ]),
+ coordinationRelays: mergeAddresses(discovered?.coordinationRelays ?? [], [
+ ...(authenticated?.coordinationRelays ?? []),
+ ...(input.coordinationRelays ?? []),
+ ]),
transitRelayPeerIds: mergeValues(
discovered?.transitRelayPeerIds ?? [],
input.transitRelayPeerIds,
diff --git a/packages/runtime-host/src/peer-mesh/node.ts b/packages/runtime-host/src/peer-mesh/node.ts
index d49068723e..be4c224b46 100644
--- a/packages/runtime-host/src/peer-mesh/node.ts
+++ b/packages/runtime-host/src/peer-mesh/node.ts
@@ -76,6 +76,7 @@ const ROUTE_PAGE_SIZE = 8;
const RECONCILE_CONCURRENCY = 4;
const RECONCILE_DEADLINE_MS = 60 * 1_000;
const RECONCILE_INTERVAL_MS = 30 * 1_000;
+const LOCAL_ROUTE_OBSERVATION_INTERVAL_MS = 1_000;
interface RedeemInvitationRequest {
readonly kind: 'redeem-invitation';
@@ -224,6 +225,7 @@ export async function openPeerMeshNode(input: {
readonly peer: PeerMeshTransport;
readonly endpointKind?: 'client' | 'host';
readonly now?: () => number;
+ readonly onBackgroundReconcileError?: (error: unknown) => void;
}): Promise<PeerMeshNode> {
const store = await openPeerMeshStateStore(input.dataRoot, input.peer.identity().peerId);
const node = new PeerMeshNodeImpl({ ...input, store });
@@ -241,6 +243,7 @@ class PeerMeshNodeImpl implements PeerMeshNode {
readonly #peer: PeerMeshTransport;
readonly #endpointKind: 'client' | 'host' | undefined;
readonly #now: () => number;
+ readonly #onBackgroundReconcileError: ((error: unknown) => void) | undefined;
readonly #activeControlStreams = new Set<RuntimeHostPeerNativeStream>();
readonly #lifetime = new AbortController();
#admissionTail = Promise.resolve();
@@ -256,11 +259,13 @@ class PeerMeshNodeImpl implements PeerMeshNode {
readonly peer: PeerMeshTransport;
readonly endpointKind?: 'client' | 'host';
readonly now?: () => number;
+ readonly onBackgroundReconcileError?: (error: unknown) => void;
}) {
this.#store = input.store;
this.#peer = input.peer;
this.#endpointKind = input.endpointKind;
this.#now = input.now ?? Date.now;
+ this.#onBackgroundReconcileError = input.onBackgroundReconcileError;
}
async initialize(): Promise<void> {
@@ -848,11 +853,11 @@ class PeerMeshNodeImpl implements PeerMeshNode {
isActiveMembership(mesh, localPeerId) && mesh.roster.roster.members.includes(peerId),
);
if (!visible) return;
- if (
- stored.routes.some(({ route }) => route.peerId === peerId && route.expiresAt > this.#now())
- ) {
- return;
- }
+ // A signed route can remain within its TTL after a peer restarted or
+ // rotated Relay reservations. Every connection establishment therefore
+ // asks the Mesh control plane for its newest record. Callers with a
+ // self-contained invitation run this reconciliation in parallel with the
+ // first dial; callers without usable routes wait for it.
await this.reconcile(signal);
}
@@ -910,10 +915,45 @@ class PeerMeshNodeImpl implements PeerMeshNode {
}
async #runReconciliation(signal: AbortSignal): Promise<void> {
+ let failureReported = false;
while (!signal.aborted) {
- await this.reconcile(signal).catch(() => undefined);
- await delay(RECONCILE_INTERVAL_MS, undefined, { signal }).catch(() => undefined);
+ try {
+ await this.reconcile(signal);
+ failureReported = false;
+ } catch (error) {
+ if (!signal.aborted && !failureReported) {
+ failureReported = true;
+ try {
+ this.#onBackgroundReconcileError?.(error);
+ } catch {
+ // Diagnostics cannot control Peer Mesh reconciliation.
+ }
+ }
+ }
+ await this.#waitForReconciliationTrigger(signal).catch(() => undefined);
+ }
+ }
+
+ async #waitForReconciliationTrigger(signal: AbortSignal): Promise<void> {
+ let remainingMs = RECONCILE_INTERVAL_MS;
+ while (!signal.aborted && remainingMs > 0) {
+ const waitMs = Math.min(LOCAL_ROUTE_OBSERVATION_INTERVAL_MS, remainingMs);
+ await delay(waitMs, undefined, { signal });
+ if (this.#localRouteRequiresRefresh()) return;
+ remainingMs -= waitMs;
+ }
+ }
+
+ #localRouteRequiresRefresh(): boolean {
+ const identity = this.#peer.identity();
+ const current = this.#store.read();
+ if (!current.meshes.some((state) => isActiveMembership(state, identity.peerId))) {
+ return false;
}
+ const existing = current.routes
+ .filter(({ route }) => route.peerId === identity.peerId)
+ .sort((left, right) => right.route.sequence - left.route.sequence)[0];
+ return !isCurrentLocalRoute(existing, identity, current, this.#endpointKind, this.#now());
}
async #reconcile(signal?: AbortSignal): Promise<void> {
@@ -1157,15 +1197,7 @@ class PeerMeshNodeImpl implements PeerMeshNode {
const existing = current.routes
.filter(({ route }) => route.peerId === identity.peerId)
.sort((left, right) => right.route.sequence - left.route.sequence)[0];
- if (
- existing &&
- existing.route.expiresAt > now + ROUTE_REFRESH_LEAD_MS &&
- sameAddresses(existing.route.routeHints, identity.listenAddresses) &&
- sameAddresses(existing.route.coordinationRelays, identity.coordinationRelays) &&
- existing.route.endpointKind === this.#endpointKind &&
- existing.route.displayName === (current.displayName ?? undefined) &&
- existing.route.transitMeshId === current.transitMeshId
- ) {
+ if (isCurrentLocalRoute(existing, identity, current, this.#endpointKind, now)) {
return { state: current, result: existing };
}
const route = await this.#signLocalRoute(current);
@@ -2124,6 +2156,24 @@ function sameAddresses(left: readonly string[], right: readonly string[]): boole
return left.length === right.length && left.every((address, index) => address === right[index]);
}
+function isCurrentLocalRoute(
+ existing: SignedPeerMeshRouteRecordV1 | undefined,
+ identity: ReturnType<PeerMeshTransport['identity']>,
+ current: Pick<PeerMeshStoredStateV1, 'displayName' | 'transitMeshId'>,
+ endpointKind: 'client' | 'host' | undefined,
+ now: number,
+): existing is SignedPeerMeshRouteRecordV1 {
+ return Boolean(
+ existing &&
+ existing.route.expiresAt > now + ROUTE_REFRESH_LEAD_MS &&
+ sameAddresses(existing.route.routeHints, identity.listenAddresses) &&
+ sameAddresses(existing.route.coordinationRelays, identity.coordinationRelays) &&
+ existing.route.endpointKind === endpointKind &&
+ existing.route.displayName === (current.displayName ?? undefined) &&
+ existing.route.transitMeshId === current.transitMeshId,
+ );
+}
+
function mergeAddresses(
primary: readonly string[],
fallback: readonly string[],
diff --git a/packages/runtime-host/src/peer-mesh/owner.ts b/packages/runtime-host/src/peer-mesh/owner.ts
index 5bde0a8d10..035ab2a46b 100644
--- a/packages/runtime-host/src/peer-mesh/owner.ts
+++ b/packages/runtime-host/src/peer-mesh/owner.ts
@@ -44,6 +44,7 @@ export async function openRuntimeHostPeerMeshOwner(input: {
readonly coordinationRelays?: readonly string[];
readonly automaticRelayDiscovery?: boolean;
readonly webRtcStunUrls?: readonly string[];
+ readonly onBackgroundReconcileError?: (error: unknown) => void;
}): Promise<RuntimeHostPeerMeshOwner> {
let mesh: PeerMeshNode | undefined;
let resolverMesh: PeerMeshNode | undefined;
@@ -77,6 +78,9 @@ export async function openRuntimeHostPeerMeshOwner(input: {
dataRoot: join(input.dataRoot, client.identity().peerId),
peer: client,
endpointKind: input.endpointKind,
+ ...(input.onBackgroundReconcileError
+ ? { onBackgroundReconcileError: input.onBackgroundReconcileError }
+ : {}),
});
resolverMesh = mesh;
} catch (error) {
diff --git a/packages/runtime-host/src/protocol/host-status.ts b/packages/runtime-host/src/protocol/host-status.ts
index 4aac3a9603..a28ef97438 100644
--- a/packages/runtime-host/src/protocol/host-status.ts
+++ b/packages/runtime-host/src/protocol/host-status.ts
@@ -51,6 +51,9 @@ export type HostUpgradePrepareResult =
export const HOST_DIAGNOSTICS_RESULT_MAX_BYTES = 72 * 1024;
export const HOST_DIAGNOSTIC_LOG_MAX_ENTRIES = 256;
export const HOST_DIAGNOSTIC_LOG_MAX_ENTRY_BYTES = 10 * 1024;
+const HOST_PEER_ID_MAX_BYTES = 160;
+const HOST_PEER_ADDRESS_MAX_BYTES = 2 * 1024;
+const HOST_PEER_ROUTE_MAX = 16;
export interface HostStatusResult {
hostEpoch: string;
@@ -60,6 +63,13 @@ export interface HostStatusResult {
connections: number;
activeOperations: number;
activeResidencies: number;
+ peerEndpoint?: HostPeerEndpoint;
+}
+
+export interface HostPeerEndpoint {
+ readonly peerId: string;
+ readonly routeHints: readonly string[];
+ readonly coordinationRelays: readonly string[];
}
export interface HostDiagnosticsResult extends HostStatusResult {
@@ -100,12 +110,26 @@ export const HOST_BOOTSTRAP_OPERATION_SPECS = {
}),
} as const;
+function decodePeerAddresses(value: unknown, label: string): readonly string[] {
+ if (!Array.isArray(value) || value.length > HOST_PEER_ROUTE_MAX) {
+ throw invalidProtocolFrame(`Invalid ${label}`);
+ }
+ const addresses = value.map((address) =>
+ requireString(address, label, HOST_PEER_ADDRESS_MAX_BYTES),
+ );
+ if (new Set(addresses).size !== addresses.length) {
+ throw invalidProtocolFrame(`Duplicate ${label}`);
+ }
+ return Object.freeze(addresses);
+}
+
function decodeEmptyHostInput(value: unknown, label: string): HostStatusInput {
requireExactRecord(value, label, []);
return {};
}
function decodeHostStatusResult(value: unknown): HostStatusResult {
+ const valueRecord = requireRecord(value, 'host.status result');
const record = requireExactRecord(value, 'host.status result', [
'hostEpoch',
'compositionId',
@@ -114,6 +138,7 @@ function decodeHostStatusResult(value: unknown): HostStatusResult {
'connections',
'activeOperations',
'activeResidencies',
+ ...(valueRecord.peerEndpoint === undefined ? [] : ['peerEndpoint']),
]);
return decodeHostStatusFields(record);
}
@@ -124,6 +149,7 @@ function decodeHostDiagnosticsResult(value: unknown): HostDiagnosticsResult {
'host.diagnostics.query result',
HOST_DIAGNOSTICS_RESULT_MAX_BYTES,
);
+ const valueRecord = requireRecord(value, 'host.diagnostics.query result');
const record = requireExactRecord(value, 'host.diagnostics.query result', [
'hostEpoch',
'compositionId',
@@ -132,6 +158,7 @@ function decodeHostDiagnosticsResult(value: unknown): HostDiagnosticsResult {
'connections',
'activeOperations',
'activeResidencies',
+ ...(valueRecord.peerEndpoint === undefined ? [] : ['peerEndpoint']),
'compositionModules',
'residencies',
'protocolVersion',
@@ -262,6 +289,25 @@ function decodeHostStatusFields(record: Record<string, unknown>): HostStatusResu
connections: requireCount(record.connections, 'connections'),
activeOperations: requireCount(record.activeOperations, 'activeOperations'),
activeResidencies: requireCount(record.activeResidencies, 'activeResidencies'),
+ ...(record.peerEndpoint === undefined
+ ? {}
+ : { peerEndpoint: decodeHostPeerEndpoint(record.peerEndpoint) }),
+ };
+}
+
+function decodeHostPeerEndpoint(value: unknown): HostPeerEndpoint {
+ const record = requireExactRecord(value, 'Runtime Host peer endpoint', [
+ 'peerId',
+ 'routeHints',
+ 'coordinationRelays',
+ ]);
+ return {
+ peerId: requireString(record.peerId, 'Runtime Host peer id', HOST_PEER_ID_MAX_BYTES),
+ routeHints: decodePeerAddresses(record.routeHints, 'Runtime Host peer route hints'),
+ coordinationRelays: decodePeerAddresses(
+ record.coordinationRelays,
+ 'Runtime Host peer coordination relays',
+ ),
};
}
diff --git a/packages/runtime-host/src/protocol/index.ts b/packages/runtime-host/src/protocol/index.ts
index a173fdbc4a..7b7c8a2cf8 100644
--- a/packages/runtime-host/src/protocol/index.ts
+++ b/packages/runtime-host/src/protocol/index.ts
@@ -100,7 +100,10 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1 as const;
export const RUNTIME_HOST_PROTOCOL_VERSION = 0 as const;
// Increment when the same protocol version no longer guarantees safe Client-Host
// interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 90 as const;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 92 as const;
+// 92: Owners can query their complete pending Session Turn-request inbox.
+// 91: Host status publishes the live Direct peer endpoint so newly issued
+// connection invitations do not preserve stale startup routes.
// 90: `session.create.mode` accepts the Bot session mode. A Host that predates
// it rejects the value as an invalid Session start mode.
// 89: The Host refreshes its models.dev catalog at startup and announces the
diff --git a/packages/runtime-host/src/protocol/operations.ts b/packages/runtime-host/src/protocol/operations.ts
index 1f6f900805..f87902936e 100644
--- a/packages/runtime-host/src/protocol/operations.ts
+++ b/packages/runtime-host/src/protocol/operations.ts
@@ -71,6 +71,7 @@ export type {
HostDiagnosticsResult,
HostActivitySnapshot,
HostLifecycleState,
+ HostPeerEndpoint,
HostStatusInput,
HostStatusResult,
HostUpgradePrepareInput,
diff --git a/packages/runtime-host/src/protocol/session-collaboration.ts b/packages/runtime-host/src/protocol/session-collaboration.ts
index cdfc55df09..81eac55fdb 100644
--- a/packages/runtime-host/src/protocol/session-collaboration.ts
+++ b/packages/runtime-host/src/protocol/session-collaboration.ts
@@ -136,7 +136,8 @@ export interface CollaborationTurnRequestCreateInput {
}
export interface CollaborationTurnRequestQueryInput {
- readonly sessionId: string;
+ /** Omit to query every request visible to the authenticated principal. */
+ readonly sessionId?: string;
}
export interface CollaborationTurnRequestQueryResult {
@@ -424,8 +425,10 @@ function decodeCollaborationTurnRequestCreateInput(
function decodeCollaborationTurnRequestQueryInput(
value: unknown,
): CollaborationTurnRequestQueryInput {
- const record = requireExactRecord(value, 'collaboration Turn request query', ['sessionId']);
- return { sessionId: requireEntityId(record.sessionId, 'sessionId') };
+ const record = requireShapedRecord(value, 'collaboration Turn request query', [], ['sessionId']);
+ return record.sessionId === undefined
+ ? {}
+ : { sessionId: requireEntityId(record.sessionId, 'sessionId') };
}
function decodeCollaborationTurnRequestQueryResult(
diff --git a/packages/runtime-host/src/server/access-authority.ts b/packages/runtime-host/src/server/access-authority.ts
index 2d7176ce28..f25fbc0e0a 100644
--- a/packages/runtime-host/src/server/access-authority.ts
+++ b/packages/runtime-host/src/server/access-authority.ts
@@ -439,12 +439,13 @@ class FileRuntimeHostAccessAuthority implements RuntimeHostAccessAuthority {
return {
canRequestTurns:
guest &&
+ input.sessionId !== undefined &&
this.activeSessionGrant(principal.principalId, input.sessionId, 'session_turn_request') !==
undefined,
requests: this.#file.turnAccessRequests.filter(
(request) =>
(!guest || request.principalId === principal.principalId) &&
- request.intent.sessionId === input.sessionId,
+ (input.sessionId === undefined || request.intent.sessionId === input.sessionId),
),
};
}
diff --git a/packages/runtime-host/src/server/execution-service.ts b/packages/runtime-host/src/server/execution-service.ts
index 1ae258c3ff..b2ee32967e 100644
--- a/packages/runtime-host/src/server/execution-service.ts
+++ b/packages/runtime-host/src/server/execution-service.ts
@@ -99,6 +99,9 @@ export async function startExecutionRuntimeHostService(
...options.peer,
dataRoot: options.peer.meshDataRoot,
endpointKind: 'host',
+ onBackgroundReconcileError: (error) => {
+ console.error('[runtime-host] Peer Mesh background synchronization failed:', error);
+ },
});
} catch (error) {
console.error(
@@ -160,7 +163,7 @@ export async function startExecutionRuntimeHostService(
}
}
-function attachPeerOwnerCleanup(
+export function attachPeerOwnerCleanup(
listeners: RuntimeHostListenerSet,
owner: RuntimeHostPeerMeshOwner,
): RuntimeHostListenerSet {
diff --git a/packages/runtime-host/src/server/host-kernel.ts b/packages/runtime-host/src/server/host-kernel.ts
index e86705ce28..491e663212 100644
--- a/packages/runtime-host/src/server/host-kernel.ts
+++ b/packages/runtime-host/src/server/host-kernel.ts
@@ -825,6 +825,7 @@ export class RuntimeHostKernel {
}
#statusSnapshot(): HostStatusResult {
+ const peer = this.peerListeners[0];
return {
hostEpoch: this.hostEpoch,
compositionId: this.compositionDescriptor.id,
@@ -833,6 +834,15 @@ export class RuntimeHostKernel {
connections: this.#acceptedTransports.size,
activeOperations: this.#activeOperations,
activeResidencies: this.#residencies.activeCount,
+ ...(peer
+ ? {
+ peerEndpoint: {
+ peerId: peer.peerId,
+ routeHints: peer.listenAddresses,
+ coordinationRelays: peer.coordinationRelays,
+ },
+ }
+ : {}),
};
}
diff --git a/packages/runtime-host/src/server/listener-set.ts b/packages/runtime-host/src/server/listener-set.ts
index c26508e581..87f8353b11 100644
--- a/packages/runtime-host/src/server/listener-set.ts
+++ b/packages/runtime-host/src/server/listener-set.ts
@@ -46,11 +46,13 @@ export interface RuntimeHostPeerListener extends RuntimeHostListener {
readonly kind: 'libp2p_direct';
readonly peerId: string;
readonly listenAddresses: readonly string[];
+ readonly coordinationRelays: readonly string[];
}
export interface RuntimeHostPeerListenerDescriptor {
readonly peerId: string;
readonly listenAddresses: readonly string[];
+ readonly coordinationRelays: readonly string[];
}
export type RuntimeHostListenerKind = 'local_ipc' | 'websocket' | 'libp2p_direct';
@@ -127,6 +129,17 @@ export function createRuntimeHostListenerSet(
additional: readonly RuntimeHostListener[] = [],
): RuntimeHostListenerSet {
const listeners = Object.freeze([local, ...additional]);
+ const peerListeners = Object.freeze(
+ additional.filter(isRuntimeHostPeerListener).map((listener) =>
+ Object.freeze({
+ peerId: listener.peerId,
+ listenAddresses: Object.freeze([...listener.listenAddresses]),
+ get coordinationRelays() {
+ return Object.freeze([...listener.coordinationRelays]);
+ },
+ }),
+ ),
+ );
return {
listeners,
localEndpoint: local.endpoint,
@@ -135,14 +148,7 @@ export function createRuntimeHostListenerSet(
.filter((listener) => listener.kind === 'websocket')
.map((listener) => listener.endpoint),
),
- peerListeners: Object.freeze(
- additional.filter(isRuntimeHostPeerListener).map((listener) =>
- Object.freeze({
- peerId: listener.peerId,
- listenAddresses: Object.freeze([...listener.listenAddresses]),
- }),
- ),
- ),
+ peerListeners,
closeAdmission: () => settleListeners(listeners, (listener) => listener.closeAdmission()),
cleanup: () => settleListeners([...listeners].reverse(), (listener) => listener.cleanup()),
};
diff --git a/packages/runtime-host/src/server/peer-listener.ts b/packages/runtime-host/src/server/peer-listener.ts
index 750f40bcce..3907669793 100644
--- a/packages/runtime-host/src/server/peer-listener.ts
+++ b/packages/runtime-host/src/server/peer-listener.ts
@@ -120,6 +120,10 @@ class RuntimeHostPeerListener implements RuntimeHostPeerListenerContract {
.catch(captureFailure);
}
+ get coordinationRelays(): readonly string[] {
+ return this.#client.identity().coordinationRelays;
+ }
+
closeAdmission(): Promise<void> {
this.#closeAdmissionTask ??= (async () => {
this.#admitting = false;
diff --git a/packages/ui/src/session-history-list.tsx b/packages/ui/src/session-history-list.tsx
index a455f9e74e..51a136574e 100644
--- a/packages/ui/src/session-history-list.tsx
+++ b/packages/ui/src/session-history-list.tsx
@@ -63,6 +63,7 @@ import { dotForStatus } from './status-vocabulary.js';
import { SessionRenameDialog, type SessionRenameTarget } from './session-rename-dialog.js';
import { CheckboxInput } from '@astryxdesign/core/CheckboxInput';
import {
+ type SessionRailData,
useSessionRailData,
useSessionRailRowSelection,
useSessionRailSelection,
@@ -286,6 +287,7 @@ function SessionListGroups(props: {
stale={rail.staleSessionIds?.has(session.id) ?? false}
worktree={rail.worktreeSessionIds?.has(session.id) ?? false}
meta={rail.sessionMeta?.(session)}
+ sessionBadge={rail.sessionBadge}
onSelectSession={rail.onSelectSession}
actions={(session as SessionSummary & { readonly shared?: true }).shared
? undefined
@@ -490,6 +492,7 @@ const SessionNavRow = memo(function SessionNavRow(props: {
stale: boolean;
worktree: boolean;
meta?: string;
+ sessionBadge?: SessionRailData['sessionBadge'];
onSelectSession(sessionId: string): void;
actions?: SessionRowActions;
onStartRename(target: SessionRenameTarget, opener: HTMLElement | null): void;
@@ -604,6 +607,11 @@ const SessionNavRow = memo(function SessionNavRow(props: {
// the two on hover or keyboard focus. The span is rendered even with
// no timestamp so the column exists on every row.
<span className="maka-session-row-end">
+ {props.sessionBadge ? (
+ <span className="maka-session-row-attention-badge">
+ {props.sessionBadge(props.session)}
+ </span>
+ ) : null}
{props.meta ? (
<span className="maka-session-row-host-badge" title={props.meta}>
<Badge variant="neutral" label={props.meta} />
diff --git a/packages/ui/src/session-rail-context.tsx b/packages/ui/src/session-rail-context.tsx
index ca747c830b..17bdcc3f85 100644
--- a/packages/ui/src/session-rail-context.tsx
+++ b/packages/ui/src/session-rail-context.tsx
@@ -52,6 +52,7 @@ export interface SessionRailData {
groups?: ReadonlyArray<SessionHistoryGroup>;
groupVariant: SessionViewMode;
sessionMeta?(session: SessionSummary): string | undefined;
+ sessionBadge?(session: SessionSummary): ReactNode;
onSelectSession(sessionId: string): void;
rowActions?: SessionRowActions;
projectActions?: ProjectRowActions;
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@maka.apache.org
For additional commands, e-mail: commits-help@maka.apache.org