@mindexec/cli 0.2.151 → 0.2.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.151",
+  "version": "0.2.153",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -21,14 +21,15 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
     "test:auth": "node scripts/auth-session-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
     "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
-    "test:remote:http": "node scripts/remote-http-smoke.mjs",
-    "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
-    "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
+    "test:remote:http": "node scripts/remote-http-smoke.mjs",
+    "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
+    "test:remote:input-ws": "node scripts/remote-input-ws-smoke.mjs",
+    "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
     "test:remote:managed": "node scripts/remote-agent-managed-smoke.mjs",
     "test:remote:registry": "node scripts/remote-registry-follower-smoke.mjs",
     "test:remote:package": "node scripts/remote-agent-package-smoke.mjs",

package/scripts/remote-fleet-render-smoke.mjs

@@ -528,7 +528,8 @@ async function loadCss3DManager() {
                 status: 200,
                 json: async () => ({
                     bridgeToken: 'render-smoke-bridge-token',
-                    remoteFrameWsPath: '/api/remote/frames/ws'
+                    remoteFrameWsPath: '/api/remote/frames/ws',
+                    remoteInputWsPath: '/api/remote/input/ws'
                 })
             };
         },
@@ -1180,21 +1181,44 @@ try {
         code: 'KeyA',
         repeat: false
     });
-    await wait(20);
-    const inputCalls = dotNetCalls.filter(call => call.methodName === 'SendRemoteFleetInputFromJs');
-    assert.ok(inputCalls.length >= 3, 'control popup should send pointer and keyboard input through JS interop');
-    const pointerDown = inputCalls.find(call => call.args[2]?.type === 'pointerDown');
-    const keyDown = inputCalls.find(call => call.args[2]?.type === 'keyDown');
+    controlShell.dispatchEvent({
+        type: 'keyup',
+        key: 'A',
+        code: 'KeyA',
+        repeat: false
+    });
+    await wait(50);
+    const inputWsSends = diagnostics.webSocketSends
+        .filter(send => send.url.includes('/api/remote/input/ws'))
+        .map(send => {
+            try {
+                return JSON.parse(send.payload);
+            } catch {
+                return null;
+            }
+        })
+        .filter(Boolean);
+    assert.ok(inputWsSends.length >= 3, 'control popup should send pointer and keyboard input over the input WebSocket');
+    const pointerDown = inputWsSends.find(message => message.input?.type === 'pointerDown');
+    const keyDown = inputWsSends.find(message => message.input?.type === 'keyDown');
+    const keyUp = inputWsSends.find(message => message.input?.type === 'keyUp');
     assert.ok(pointerDown);
     assert.ok(keyDown);
-    assert.equal(pointerDown.args[0], 'remote-fleet-render-smoke');
-    assert.equal(pointerDown.args[1], patchTarget.DeviceId);
-    assert.equal(pointerDown.args[2].button, 'left');
-    assert.ok(pointerDown.args[2].controlLeaseId);
-    assert.ok(pointerDown.args[2].normalizedX >= 0 && pointerDown.args[2].normalizedX <= 1);
-    assert.ok(pointerDown.args[2].normalizedY >= 0 && pointerDown.args[2].normalizedY <= 1);
-    assert.equal(keyDown.args[2].key, 'A');
-    assert.equal(keyDown.args[2].code, 'KeyA');
+    assert.ok(keyUp);
+    assert.equal(pointerDown.nodeId, 'remote-fleet-render-smoke');
+    assert.equal(pointerDown.deviceId, patchTarget.DeviceId);
+    assert.equal(pointerDown.input.button, 'left');
+    assert.ok(pointerDown.input.controlLeaseId);
+    assert.ok(pointerDown.input.normalizedX >= 0 && pointerDown.input.normalizedX <= 1);
+    assert.ok(pointerDown.input.normalizedY >= 0 && pointerDown.input.normalizedY <= 1);
+    assert.equal(keyDown.input.key, 'A');
+    assert.equal(keyDown.input.code, 'KeyA');
+    assert.equal(keyUp.input.key, 'A');
+    assert.equal(keyUp.input.code, 'KeyA');
+    assert.equal(
+        dotNetCalls.filter(call => call.methodName === 'SendRemoteFleetInputFromJs').length,
+        0,
+        'WebSocket input path should not use the slower DotNet input fallback in the happy path');
     manager.closeRemoteFleetControlPopupForTest('render-smoke');
     await wait(20);
     assert.equal(document.body.querySelector('[data-remote-fleet-control-popup="true"]'), null);

package/scripts/remote-input-ws-smoke.mjs

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocket } from 'ws';
+
+const BRIDGE_TOKEN = 'remote-input-ws-smoke-token';
+const PAIR_TOKEN = 'remote-input-ws-pair-token';
+const DEVICE_ID = 'remote-input-ws-device';
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate, timeoutMs = 10000, label = 'condition') {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const value = await predicate();
+        if (value) {
+            return value;
+        }
+        await wait(50);
+    }
+
+    throw new Error(`Timed out waiting for ${label}.`);
+}
+
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+
+async function fetchJson(url, options = {}) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+            'X-Bridge-Token': BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+    const payload = await response.json().catch(() => null);
+    return { ok: response.ok, status: response.status, payload };
+}
+
+async function waitForBridge(baseUrl, details) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30000) {
+        try {
+            const result = await fetchJson(`${baseUrl}/api/remote/status`);
+            if (result.ok && result.payload?.started === true) {
+                return result.payload;
+            }
+        } catch {
+            // Server is still starting.
+        }
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for LocalBridge.\n${details()}`);
+}
+
+function spawnBridge({ bridgePort, remoteHubPort }) {
+    const bridgeRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    const env = {
+        ...process.env,
+        BRIDGE_PORT: String(bridgePort),
+        BRIDGE_TOKEN,
+        BRIDGE_REQUIRE_TOKEN: '1',
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: String(remoteHubPort),
+        REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+        NO_COLOR: '1'
+    };
+
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: bridgeRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+
+    const exitPromise = new Promise(resolve => child.once('exit', resolve));
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([exitPromise, wait(5000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        details: () => `stdout=${stdout}\nstderr=${stderr}`,
+        stop
+    };
+}
+
+async function openWebSocket(url) {
+    const ws = new WebSocket(url);
+    await new Promise((resolve, reject) => {
+        ws.once('open', resolve);
+        ws.once('error', reject);
+    });
+    return ws;
+}
+
+async function main() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, remoteHubPort });
+    let agentWs = null;
+    let inputWs = null;
+
+    try {
+        await waitForBridge(bridge.baseUrl, bridge.details);
+
+        const receivedCommands = [];
+        agentWs = await openWebSocket(`ws://127.0.0.1:${remoteHubPort}/remote-agent`);
+        agentWs.on('message', data => {
+            const text = Buffer.isBuffer(data) ? data.toString('utf8') : String(data || '');
+            if (!text.trim().startsWith('{')) {
+                return;
+            }
+
+            const message = JSON.parse(text);
+            if (message.command === 'input.control') {
+                receivedCommands.push(message);
+            }
+        });
+        agentWs.send(JSON.stringify({
+            type: 'hello',
+            pairToken: PAIR_TOKEN,
+            deviceId: DEVICE_ID,
+            deviceName: 'Remote Input WS Smoke',
+            hostname: 'remote-input-ws-smoke',
+            platform: process.platform,
+            arch: process.arch,
+            pid: process.pid,
+            agentVersion: '0.0.0-input-ws-smoke',
+            runtime: 'node-smoke',
+            capabilities: {
+                status: true,
+                thumbnail: true,
+                liveStream: true,
+                binaryFrames: true,
+                control: true,
+                computerAgent: true,
+                taskDispatch: true,
+                aiAssist: false
+            }
+        }));
+        agentWs.send(JSON.stringify({
+            type: 'status',
+            status: {
+                uptimeSec: 1,
+                totalMem: 2,
+                freeMem: 1,
+                timestamp: new Date().toISOString()
+            }
+        }));
+
+        await waitFor(async () => {
+            const result = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+            return result.payload?.devices?.find(device => device.deviceId === DEVICE_ID && device.connected === true);
+        }, 10000, 'device registration');
+
+        inputWs = await openWebSocket(`${bridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/input/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`);
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'pointer-move',
+            input: {
+                type: 'pointerMove',
+                normalizedX: 0.42,
+                normalizedY: 0.54,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'key-down',
+            input: {
+                type: 'keyDown',
+                key: 'A',
+                code: 'KeyA',
+                repeat: false,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'key-up',
+            input: {
+                type: 'keyUp',
+                key: 'A',
+                code: 'KeyA',
+                repeat: false,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+
+        await waitFor(() => receivedCommands.length >= 3, 10000, 'input.control commands');
+        const commandTypes = receivedCommands.map(command => command.payload?.type);
+        assert.deepEqual(commandTypes.slice(0, 3), ['pointerMove', 'keyDown', 'keyUp']);
+        assert.equal(receivedCommands[0].payload.normalizedX, 0.42);
+        assert.equal(receivedCommands[0].payload.normalizedY, 0.54);
+        assert.equal(receivedCommands[1].payload.key, 'A');
+        assert.equal(receivedCommands[1].payload.code, 'KeyA');
+        assert.equal(receivedCommands[2].payload.key, 'A');
+        assert.equal(receivedCommands[2].payload.code, 'KeyA');
+
+        const status = await fetchJson(`${bridge.baseUrl}/api/status?remoteInput=ws`);
+        assert.equal(status.ok, true);
+        assert.equal(status.payload?.remoteInputWsPath, '/api/remote/input/ws');
+        assert.ok(status.payload?.remoteInputWs?.clientCount >= 1, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.inputsQueued >= 3, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.pointerMovesQueued >= 1, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.keyEventsQueued >= 2, JSON.stringify(status.payload?.remoteInputWs));
+        assert.equal(status.payload?.remoteInputWs?.lastDeviceId, DEVICE_ID);
+        assert.equal(status.payload?.remoteInputWs?.lastInputType, 'keyUp');
+
+        console.log('Remote input WebSocket smoke OK');
+    } finally {
+        if (inputWs && inputWs.readyState === WebSocket.OPEN) {
+            inputWs.close();
+        }
+        if (agentWs && agentWs.readyState === WebSocket.OPEN) {
+            agentWs.close();
+        }
+        await bridge.stop();
+    }
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/scripts/remote-registry-follower-smoke.mjs

@@ -83,10 +83,17 @@ function createRegistryTarget({ endpoint, endpointCandidates, leaseId, active =
     };
 }
 
-function startFakeSupabase(getTarget) {
+function startFakeSupabase(getTarget, setTarget = null) {
     const requests = [];
     const realtimeClients = new Set();
-    const server = createServer((req, res) => {
+    const server = createServer(async (req, res) => {
+        const readBody = () => new Promise(resolve => {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk.toString();
+            });
+            req.on('end', () => resolve(body));
+        });
         const parsed = new URL(req.url || '/', 'http://127.0.0.1');
         requests.push({
             method: req.method,
@@ -107,6 +114,40 @@ function startFakeSupabase(getTarget) {
             return;
         }
 
+        if (req.method === 'POST' && parsed.pathname === '/rest/v1/rpc/set_remote_host_target') {
+            assert.equal(String(req.headers.apikey || ''), SUPABASE_KEY);
+            assert.equal(String(req.headers.authorization || ''), `Bearer ${ACCESS_TOKEN}`);
+            const body = JSON.parse(await readBody() || '{}');
+            const now = Date.now();
+            const existing = getTarget();
+            const sameLease = existing
+                && String(existing.lease_id || '') === String(body.p_lease_id || '')
+                && String(existing.host_instance_id || '') === String(body.p_host_instance_id || '');
+            const expired = !existing?.expires_at || Date.parse(existing.expires_at) <= now;
+            if (existing?.active === true && !sameLease && !expired && body.p_takeover !== true) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify([{ ok: false, reason: 'host-target-taken' }]));
+                return;
+            }
+
+            setTarget?.({
+                user_id: USER_ID,
+                active: true,
+                endpoint: String(body.p_endpoint || ''),
+                endpoint_candidates: Array.isArray(body.p_endpoint_candidates)
+                    ? body.p_endpoint_candidates
+                    : [String(body.p_endpoint || '')].filter(Boolean),
+                pair_token: String(body.p_pair_token || ''),
+                lease_id: String(body.p_lease_id || ''),
+                node_id: String(body.p_node_id || ''),
+                host_instance_id: String(body.p_host_instance_id || ''),
+                expires_at: String(body.p_expires_at || new Date(Date.now() + 60_000).toISOString())
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify([{ ok: true, reason: 'ok' }]));
+            return;
+        }
+
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'not-found' }));
     });
@@ -230,7 +271,7 @@ function startFakeSupabase(getTarget) {
     });
 }
 
-function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label, supabaseUrl = '', follower = false }) {
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label, supabaseUrl = '', follower = false, publicHost = '' }) {
     const child = spawn(process.execPath, ['server.js'], {
         cwd: LOCAL_BRIDGE_DIR,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -243,6 +284,7 @@ function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label
             MINDEXEC_REMOTE_HUB: '1',
             REMOTE_HUB_HOST: '127.0.0.1',
             REMOTE_HUB_PORT: String(remoteHubPort),
+            REMOTE_HUB_PUBLIC_HOST: publicHost,
             REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
             WORKSPACE_PATH: workspacePath,
             MINDEXEC_AUTH_DATA_ROOT: authRoot,
@@ -251,6 +293,7 @@ function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label
             MINDEXEC_REMOTE_REGISTRY_FAST_RETRY_MS: '250',
             MINDEXEC_REMOTE_REGISTRY_REALTIME_RECONNECT_MS: '250',
             MINDEXEC_REMOTE_REGISTRY_REALTIME_DEBOUNCE_MS: '100',
+            MINDEXEC_REMOTE_HOST_TARGET_RENEW_MS: '5000',
             SUPABASE_URL: supabaseUrl,
             SUPABASE_KEY,
             NO_COLOR: '1'
@@ -353,10 +396,13 @@ function killProcess(pid) {
 async function main() {
     const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-registry-smoke-'));
     let fakeSupabase = null;
+    let renewHost = null;
     let hostA = null;
     let hostB = null;
     let client = null;
 
+    const renewHostBridgePort = await findFreePort();
+    const renewHostRemotePort = await findFreePort();
     const hostABridgePort = await findFreePort();
     const hostARemotePort = await findFreePort();
     const hostBBridgePort = await findFreePort();
@@ -364,23 +410,82 @@ async function main() {
     const clientBridgePort = await findFreePort();
     const clientRemotePort = await findFreePort();
     const stalePort = await findFreePort();
+    const renewPublicHost = '192.0.2.10';
+    const renewPublicEndpoint = `${renewPublicHost}:${renewHostRemotePort}`;
     const hostAEndpoint = `127.0.0.1:${hostARemotePort}`;
     const hostBEndpoint = `127.0.0.1:${hostBRemotePort}`;
     const staleEndpoint = `127.0.0.1:${stalePort}`;
-    let currentTarget = createRegistryTarget({
-        endpoint: hostAEndpoint,
-        endpointCandidates: [staleEndpoint, hostAEndpoint],
-        leaseId: 'lease-a'
-    });
+    let currentTarget = null;
 
     try {
-        fakeSupabase = await startFakeSupabase(() => currentTarget);
+        fakeSupabase = await startFakeSupabase(
+            () => currentTarget,
+            target => {
+                currentTarget = target;
+            });
 
+        const renewHostAuth = path.join(tempRoot, 'auth-renew-host');
         const hostAAuth = path.join(tempRoot, 'auth-host-a');
         const hostBAuth = path.join(tempRoot, 'auth-host-b');
         const clientAuth = path.join(tempRoot, 'auth-client');
+        await writeSession(renewHostAuth);
         await writeSession(clientAuth);
 
+        renewHost = spawnBridge({
+            bridgePort: renewHostBridgePort,
+            remoteHubPort: renewHostRemotePort,
+            workspacePath: path.join(tempRoot, 'renew-host'),
+            authRoot: renewHostAuth,
+            label: 'renew-host',
+            supabaseUrl: fakeSupabase.url,
+            follower: true,
+            publicHost: renewPublicHost
+        });
+        await waitForBridge(renewHost);
+
+        const renewSetHost = await fetchJson(`${renewHost.baseUrl}/api/remote/host-target`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({
+                nodeId: 'remote-registry-renew-node',
+                enabled: true,
+                leaseMs: 60000
+            })
+        });
+        assert.equal(renewSetHost.ok, true, JSON.stringify(renewSetHost.payload));
+        assert.equal(renewSetHost.payload?.ok, true, JSON.stringify(renewSetHost.payload));
+        assert.equal(renewSetHost.payload?.active, true, JSON.stringify(renewSetHost.payload));
+        assert.equal(renewSetHost.payload?.hostTargetRenew?.status, 'active', JSON.stringify(renewSetHost.payload?.hostTargetRenew));
+        assert.equal(currentTarget?.endpoint, renewPublicEndpoint, JSON.stringify(currentTarget));
+        assert.equal(currentTarget?.node_id, 'remote-registry-renew-node', JSON.stringify(currentTarget));
+        await waitFor(() => {
+            const publishCount = fakeSupabase.requests.filter(request =>
+                request.method === 'POST'
+                && request.pathname === '/rest/v1/rpc/set_remote_host_target').length;
+            return publishCount >= 2 ? publishCount : null;
+        }, 8000, `host-target auto renew publish\n${renewHost.details()}`);
+        const renewStatus = await fetchJson(`${renewHost.baseUrl}/api/status`);
+        assert.equal(renewStatus.payload?.remoteHostTargetRenew?.status, 'active', JSON.stringify(renewStatus.payload?.remoteHostTargetRenew));
+        assert.equal(renewStatus.payload?.remoteHostTargetRenew?.endpoint, renewPublicEndpoint, JSON.stringify(renewStatus.payload?.remoteHostTargetRenew));
+
+        const renewClear = await fetchJson(`${renewHost.baseUrl}/api/remote/host-target`, {
+            method: 'DELETE',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({
+                nodeId: 'remote-registry-renew-node'
+            })
+        });
+        assert.equal(renewClear.ok, true, JSON.stringify(renewClear.payload));
+        assert.equal(renewClear.payload?.ok, true, JSON.stringify(renewClear.payload));
+        await renewHost.stop();
+        renewHost = null;
+
+        currentTarget = createRegistryTarget({
+            endpoint: hostAEndpoint,
+            endpointCandidates: [staleEndpoint, hostAEndpoint],
+            leaseId: 'lease-a'
+        });
+
         hostA = spawnBridge({
             bridgePort: hostABridgePort,
             remoteHubPort: hostARemotePort,
@@ -465,6 +570,7 @@ async function main() {
         if (client) await client.stop();
         if (hostB) await hostB.stop();
         if (hostA) await hostA.stop();
+        if (renewHost) await renewHost.stop();
         if (fakeSupabase) await fakeSupabase.stop();
         await rm(tempRoot, { recursive: true, force: true });
     }