@mindexec/cli 0.2.24 → 0.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.24",
+  "version": "0.2.25",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/remote-hub.js

@@ -15,6 +15,7 @@ const RECENT_TASK_LIMIT = 12;
 const RECENT_TASK_BATCH_LIMIT = 16;
 const REMOTE_PROTOCOL_VERSION = 1;
 const MAX_SYNTHETIC_DEVICES = 1000;
+const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
 const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
 
 function isEnabledValue(value, fallback = true) {
@@ -219,9 +220,129 @@ export function createRemoteHub(options = {}) {
     let started = false;
     let boundPort = requestedPort;
     let lastError = '';
+    let hostTarget = null;
+
+    function getAgentEndpoint() {
+        return `${host}:${boundPort || requestedPort}`;
+    }
+
+    function getActiveHostTarget() {
+        if (!hostTarget) {
+            return null;
+        }
+
+        const expiresMs = Date.parse(hostTarget.expiresAt || '');
+        if (Number.isFinite(expiresMs) && expiresMs <= Date.now()) {
+            const expiredTarget = hostTarget;
+            hostTarget = null;
+            emitRemoteEvent('RemoteHostTargetExpired', null, {
+                hostTarget: {
+                    ...expiredTarget,
+                    active: false
+                }
+            });
+            return null;
+        }
+
+        return hostTarget;
+    }
+
+    function serializeHostTarget(target = getActiveHostTarget()) {
+        if (!target) {
+            return {
+                active: false,
+                nodeId: '',
+                leaseId: '',
+                endpoint: '',
+                activatedAt: '',
+                updatedAt: '',
+                expiresAt: ''
+            };
+        }
+
+        return {
+            active: true,
+            nodeId: target.nodeId,
+            leaseId: target.leaseId,
+            endpoint: target.endpoint,
+            activatedAt: target.activatedAt,
+            updatedAt: target.updatedAt,
+            expiresAt: target.expiresAt
+        };
+    }
+
+    function setHostTarget(options = {}) {
+        const enabled = options.enabled !== false;
+        const nodeId = safeString(options.nodeId, 128);
+        if (!enabled) {
+            const previous = getActiveHostTarget();
+            if (!previous) {
+                return {
+                    ok: true,
+                    active: false,
+                    hostTarget: serializeHostTarget(null)
+                };
+            }
+
+            if (nodeId && previous.nodeId && nodeId !== previous.nodeId) {
+                return {
+                    ok: false,
+                    error: 'host-target-node-mismatch',
+                    active: true,
+                    hostTarget: serializeHostTarget(previous)
+                };
+            }
+
+            hostTarget = null;
+            emitRemoteEvent('RemoteHostTargetCleared', null, {
+                hostTarget: {
+                    ...serializeHostTarget(previous),
+                    active: false
+                }
+            });
+            return {
+                ok: true,
+                active: false,
+                hostTarget: serializeHostTarget(null)
+            };
+        }
+
+        if (!nodeId) {
+            return {
+                ok: false,
+                error: 'missing-node-id',
+                active: false,
+                hostTarget: serializeHostTarget()
+            };
+        }
+
+        const now = new Date();
+        const leaseMs = clampNumber(options.leaseMs, 5000, 10 * 60 * 1000, DEFAULT_HOST_TARGET_LEASE_MS);
+        const previous = getActiveHostTarget();
+        const activeSameNode = previous?.nodeId === nodeId;
+        hostTarget = {
+            nodeId,
+            leaseId: activeSameNode && previous?.leaseId ? previous.leaseId : crypto.randomUUID(),
+            endpoint: getAgentEndpoint(),
+            activatedAt: activeSameNode && previous?.activatedAt ? previous.activatedAt : now.toISOString(),
+            updatedAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + leaseMs).toISOString()
+        };
+
+        emitRemoteEvent('RemoteHostTargetSet', null, {
+            hostTarget: serializeHostTarget(hostTarget),
+            replacedNodeId: previous && previous.nodeId !== nodeId ? previous.nodeId : ''
+        });
+        return {
+            ok: true,
+            active: true,
+            hostTarget: serializeHostTarget(hostTarget)
+        };
+    }
 
     function getStatus({ includeSecrets = false } = {}) {
         const connectedDevices = [...devices.values()].filter(device => device.connected).length;
+        const activeHostTarget = serializeHostTarget();
         return {
             enabled,
             started,
@@ -234,13 +355,20 @@ export function createRemoteHub(options = {}) {
             managerPackage,
             managerVersion,
             agentPackage: '@mindexec/remote',
-            agentEndpoint: `${host}:${boundPort || requestedPort}`,
+            agentEndpoint: getAgentEndpoint(),
             pairToken: includeSecrets ? pairToken : undefined,
             pairTokenPreview: maskToken(pairToken),
             deviceCount: devices.size,
             connectedDeviceCount: connectedDevices,
             canvasDeviceListMode: 'all-devices',
             canvasPagination: 'none',
+            hostTargetActive: activeHostTarget.active,
+            hostTargetNodeId: activeHostTarget.nodeId,
+            hostTargetLeaseId: activeHostTarget.leaseId,
+            hostTargetEndpoint: activeHostTarget.endpoint,
+            hostTargetActivatedAt: activeHostTarget.activatedAt,
+            hostTargetUpdatedAt: activeHostTarget.updatedAt,
+            hostTargetExpiresAt: activeHostTarget.expiresAt,
             externalExposure: host === '0.0.0.0' || host === '::',
             lastError
         };
@@ -1690,6 +1818,7 @@ export function createRemoteHub(options = {}) {
         sendCommand,
         requestAgentTask,
         requestAgentTaskBatch,
+        setHostTarget,
         requestThumbnail,
         startLiveStream,
         stopLiveStream,

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

@@ -416,6 +416,9 @@ function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTask
     const connected = devices.filter(device => device.Connected).length;
     const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
     const pairToken = hubStatus.pairToken || 'render-smoke-token';
+    const hostTargetState = hubStatus.hostTargetActive
+        ? (hubStatus.hostTargetNodeId === 'remote-fleet-render-smoke' ? 'hosting' : 'other-monitor')
+        : 'inactive';
     return {
         id: 'remote-fleet-render-smoke',
         contentType: 'memo',
@@ -434,6 +437,13 @@ function buildMonitorNode(devices, hubStatus, latestTaskBatch = null, recentTask
             RemoteFleetDeviceCount: String(devices.length),
             RemoteFleetConnectedDeviceCount: String(connected),
             RemoteFleetCanvasPagination: 'none',
+            RemoteFleetHostTargetState: hostTargetState,
+            RemoteFleetHostTargetNodeId: hubStatus.hostTargetNodeId || '',
+            RemoteFleetHostTargetLeaseId: hubStatus.hostTargetLeaseId || '',
+            RemoteFleetHostTargetEndpoint: hubStatus.hostTargetEndpoint || endpoint,
+            RemoteFleetHostTargetActivatedAtUtc: hubStatus.hostTargetActivatedAt || '',
+            RemoteFleetHostTargetUpdatedAtUtc: hubStatus.hostTargetUpdatedAt || '',
+            RemoteFleetHostTargetExpiresAtUtc: hubStatus.hostTargetExpiresAt || '',
             RemoteFleetDevicesJson: JSON.stringify(devices),
             RemoteFleetLatestTaskBatchJson: latestTaskBatch ? JSON.stringify(latestTaskBatch) : '',
             RemoteFleetRecentTaskBatchesJson: JSON.stringify(recentTaskBatches),
@@ -645,6 +655,13 @@ try {
                 };
             }
 
+            if (methodName === 'SetRemoteFleetHostFromJs') {
+                return {
+                    success: true,
+                    active: args[1] === true
+                };
+            }
+
             return { success: true };
         }
     };
@@ -660,16 +677,69 @@ try {
     let cards = bodyView.querySelectorAll('article[data-device-id]');
     assert.equal(cards.length, SYNTHETIC_COUNT);
     assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${SYNTHETIC_COUNT}/${SYNTHETIC_COUNT}`);
-    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').length, SYNTHETIC_COUNT);
-    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="task-device"]').length, connectedCount);
-    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="thumbnail-device"]').length, devices.filter(device => device.Connected && device.ThumbnailEnabled).length);
+    assert.ok(bodyView.querySelector('[data-remote-fleet-device-grid="true"]'));
+    const initialDetailPanel = bodyView.querySelector('[data-remote-fleet-detail-panel="true"]');
+    assert.equal(initialDetailPanel?.dataset.deviceId, focusedDevice.DeviceId);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').length, 1);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="task-device"]').length, 0);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="thumbnail-device"]').length, focusedDevice.Connected && focusedDevice.ThumbnailEnabled ? 1 : 0);
+    assert.ok(initialDetailPanel?.textContent.includes('Seen'));
+    assert.ok(initialDetailPanel?.textContent.includes('Uptime'));
+    assert.ok(initialDetailPanel?.textContent.includes('Mem'));
+    assert.ok(initialDetailPanel?.textContent.includes('Load'));
+    assert.ok(cards[0]?.querySelector('[data-remote-fleet-device-preview="tile"]'));
+    assert.equal(/\b(Seen|Uptime|Mem|Load)\b/.test(cards[0]?.textContent || ''), false);
+    const alternateDevice = devices.find(device => device.DeviceId !== focusedDevice.DeviceId);
+    assert.ok(alternateDevice);
+    const alternateCard = Array.from(cards).find(card => card.dataset.deviceId === alternateDevice.DeviceId);
+    assert.ok(alternateCard);
+    alternateCard.dispatchEvent({ type: 'click' });
+    assert.equal(bodyView.dataset.remoteFleetSelectedDeviceId, alternateDevice.DeviceId);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-detail-panel="true"]')?.dataset.deviceId, alternateDevice.DeviceId);
     const livePanel = bodyView.querySelector('[data-remote-fleet-live-panel="true"]');
     assert.equal(livePanel?.dataset.deviceId, focusedDevice.DeviceId);
-    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-visible"]')?.disabled, false);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-visible"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-connected"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-task-input="true"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]'), null);
     assert.ok(bodyView.textContent.includes('all devices, no paging'));
+    assert.equal(bodyView.querySelector('[data-remote-fleet-host-state="true"]')?.textContent.includes('Host: Inactive'), true);
+    const initialHostButton = bodyView.querySelector('[data-remote-fleet-action="set-host"]');
+    assert.equal(initialHostButton?.textContent, 'Set Host');
+    initialHostButton.dispatchEvent({ type: 'click' });
+    await wait();
+    const setHostCall = dotNetCalls.find(call => call.methodName === 'SetRemoteFleetHostFromJs');
+    assert.ok(setHostCall);
+    assert.equal(setHostCall.args[0], 'remote-fleet-render-smoke');
+    assert.equal(setHostCall.args[1], true);
+
+    hub.setHostTarget({
+        nodeId: 'remote-fleet-render-smoke',
+        enabled: true,
+        leaseMs: 30000
+    });
+    manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true }), latestTaskBatch, recentTaskBatches));
+    assert.equal(bodyView.querySelector('[data-remote-fleet-host-state="true"]')?.textContent.includes('Host: Active'), true);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="set-host"]')?.textContent, 'Hosting');
+    const stopHostButton = bodyView.querySelector('[data-remote-fleet-action="stop-host"]');
+    assert.ok(stopHostButton);
+    const stopHostStart = dotNetCalls.length;
+    stopHostButton.dispatchEvent({ type: 'click' });
+    await wait();
+    const stopHostCall = dotNetCalls
+        .slice(stopHostStart)
+        .find(call => call.methodName === 'SetRemoteFleetHostFromJs');
+    assert.ok(stopHostCall);
+    assert.equal(stopHostCall.args[0], 'remote-fleet-render-smoke');
+    assert.equal(stopHostCall.args[1], false);
+
     assert.match(bodyView.querySelector('[data-remote-fleet-manager-version="true"]')?.textContent || '', /^@mindexec\/cli render-smoke-manager - 127\.0\.0\.1:\d+$/);
     assert.ok(livePanel?.textContent.includes('RemoteFast 20 fps'), livePanel?.textContent || bodyView.textContent);
-    assert.ok(bodyView.querySelector('code')?.textContent.includes('npx @mindexec/remote connect'));
+    assert.equal(bodyView.querySelector('code'), null);
+    assert.equal(bodyView.textContent.includes('npx @mindexec/remote connect'), false);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="copy-command"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="refresh"]'), null);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-auto-toggle="true"]'), null);
     assert.ok(bodyView.textContent.includes('synthetic-render-ai'));
     assert.ok(bodyView.textContent.includes('Task timed out waiting for the agent response.'));
     const batchSummary = bodyView.querySelector('[data-remote-fleet-task-batch="true"]');
@@ -719,63 +789,20 @@ try {
     assert.ok(bodyView.querySelectorAll('[data-remote-fleet-group-header="true"]').length >= 2);
     assert.equal(bodyView.querySelectorAll('article[data-device-id]').length, SYNTHETIC_COUNT);
 
-    const taskInput = bodyView.querySelector('[data-remote-fleet-task-input="true"]');
-    const sendVisibleButton = bodyView.querySelector('[data-remote-fleet-action="task-visible"]');
-    assert.ok(taskInput);
-    assert.ok(sendVisibleButton);
-    taskInput.value = 'Dispatch smoke partial failure';
-    sendVisibleButton.dispatchEvent({ type: 'click' });
-    await wait();
-    const batchCall = dotNetCalls.find(call => call.methodName === 'DispatchRemoteFleetTaskBatchFromJs');
-    assert.ok(batchCall);
-    const batchTargetIds = Array.isArray(batchCall.args[1]) ? batchCall.args[1] : [];
-    assert.equal(batchTargetIds.length, connectedCount);
     const feedback = bodyView.querySelector('[data-remote-fleet-task-feedback="true"]');
     assert.ok(feedback);
-    assert.equal(feedback.style.display, 'block');
-    assert.match(feedback.textContent, new RegExp(`Queued ${connectedCount - 1}/${connectedCount} visible remote task\\(s\\); 1 failed`));
-    assert.match(feedback.textContent, /device-ai-assist-unavailable/);
+    assert.equal(feedback.style.display, 'none');
 
     const activeSelects = bodyView.querySelectorAll('select');
     assert.equal(activeSelects.length, 4);
     const [aiFilterSelect] = activeSelects;
-    const aiToggle = bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]');
-    assert.ok(aiToggle);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-ai-toggle="true"]'), null);
     aiFilterSelect.value = 'ai';
     aiFilterSelect.dispatchEvent({ type: 'change' });
-    aiToggle.checked = true;
-    aiToggle.dispatchEvent({ type: 'change' });
     assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${aiCount}/${SYNTHETIC_COUNT}`);
-    assert.equal(sendVisibleButton.disabled, false);
-    taskInput.value = 'Dispatch visible AI smoke';
-    const aiDispatchCallStart = dotNetCalls.length;
-    sendVisibleButton.dispatchEvent({ type: 'click' });
-    await wait();
-    const aiBatchCall = dotNetCalls
-        .slice(aiDispatchCallStart)
-        .find(call => call.methodName === 'DispatchRemoteFleetTaskBatchFromJs');
-    assert.ok(aiBatchCall);
-    const aiTargetIds = Array.isArray(aiBatchCall.args[1]) ? aiBatchCall.args[1] : [];
-    const expectedAiTargetIds = devices
-        .filter(device => device.Connected && device.AiAssistEnabled)
-        .map(device => device.DeviceId)
-        .sort();
-    assert.deepEqual([...aiTargetIds].sort(), expectedAiTargetIds);
-    assert.equal(aiBatchCall.args[3], true);
-
-    const sendConnectedButton = bodyView.querySelector('[data-remote-fleet-action="task-connected"]');
-    assert.ok(sendConnectedButton);
-    taskInput.value = 'Dispatch all AI smoke';
-    const allAiDispatchCallStart = dotNetCalls.length;
-    sendConnectedButton.dispatchEvent({ type: 'click' });
-    await wait();
-    const allAiCall = dotNetCalls
-        .slice(allAiDispatchCallStart)
-        .find(call => call.methodName === 'DispatchRemoteFleetTaskFromJs');
-    assert.ok(allAiCall);
-    assert.equal(allAiCall.args[1], '');
-    assert.equal(allAiCall.args[3], true);
-    assert.match(feedback.textContent, new RegExp(`Queued ${aiCount}/${aiCount} AI task\\(s\\)`));
+    assert.equal(dotNetCalls.some(call =>
+        call.methodName === 'DispatchRemoteFleetTaskBatchFromJs'
+        || call.methodName === 'DispatchRemoteFleetTaskFromJs'), false);
 
     const deviceBody = document.createElement('div');
     document.body.appendChild(deviceBody);

package/scripts/remote-http-smoke.mjs

@@ -51,11 +51,11 @@ async function fetchJson(url, options = {}) {
     };
 }
 
-async function waitForBridge(baseUrl, getFailureDetails) {
+async function waitForBridge(baseUrl, getFailureDetails, bridgeToken = BRIDGE_TOKEN) {
     const startedAt = Date.now();
     while (Date.now() - startedAt < 30000) {
         try {
-            const result = await fetchJson(`${baseUrl}/api/remote/status`, { token: BRIDGE_TOKEN });
+            const result = await fetchJson(`${baseUrl}/api/remote/status`, { token: bridgeToken });
             if (result.ok && result.payload?.started === true) {
                 return result.payload;
             }
@@ -70,49 +70,96 @@ async function waitForBridge(baseUrl, getFailureDetails) {
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const bridgeRoot = path.resolve(__dirname, '..');
-const bridgePort = await findFreePort();
-const remoteHubPort = await findFreePort();
-const baseUrl = `http://127.0.0.1:${bridgePort}`;
-
-const child = spawn(process.execPath, ['server.js'], {
-    cwd: bridgeRoot,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true,
-    env: {
+
+function spawnBridge({
+    bridgePort,
+    remoteHubPort,
+    bridgeToken = BRIDGE_TOKEN,
+    pairToken = PAIR_TOKEN,
+    syntheticFleetEnabled = false
+}) {
+    const env = {
         ...process.env,
         BRIDGE_PORT: String(bridgePort),
-        BRIDGE_TOKEN,
+        BRIDGE_TOKEN: bridgeToken,
         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,
-        MINDEXEC_REMOTE_SYNTHETIC_FLEET: '1',
+        REMOTE_HUB_PAIR_TOKEN: pairToken,
         NO_COLOR: '1'
+    };
+
+    delete env.MINDEXEC_REMOTE_SYNTHETIC_FLEET;
+    delete env.REMOTE_HUB_SYNTHETIC_FLEET;
+    if (syntheticFleetEnabled) {
+        env.MINDEXEC_REMOTE_SYNTHETIC_FLEET = '1';
     }
-});
-
-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 details = () => `stdout=${stdout}\nstderr=${stderr}`;
-
-try {
-    const status = await waitForBridge(baseUrl, details);
+
+    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 details = () => `stdout=${stdout}\nstderr=${stderr}`;
+    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}`,
+        bridgePort,
+        remoteHubPort,
+        bridgeToken,
+        pairToken,
+        child,
+        details,
+        stop
+    };
+}
+
+async function runSyntheticEnabledSmoke() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({
+        bridgePort,
+        remoteHubPort,
+        syntheticFleetEnabled: true
+    });
+    const { baseUrl } = bridge;
+    const details = bridge.details;
+
+    try {
+    const status = await waitForBridge(baseUrl, details, bridge.bridgeToken);
     assert.equal(status.started, true);
     assert.equal(status.port, remoteHubPort);
     assert.equal(status.managerPackage, '@mindexec/cli');
-    assert.equal(status.managerVersion, '0.2.24');
+    assert.equal(status.managerVersion, '0.2.25');
     assert.equal(status.agentPackage, '@mindexec/remote');
     assert.equal(status.canvasPagination, 'none');
     assert.equal(status.canvasDeviceListMode, 'all-devices');
+    assert.equal(status.hostTargetActive, false);
     assert.equal(status.pairToken, PAIR_TOKEN);
 
     const unauthorizedStatus = await fetchJson(`${baseUrl}/api/remote/status`);
@@ -124,6 +171,58 @@ try {
     });
     assert.equal(unauthorizedDelete.status, 401);
 
+    const unauthorizedHost = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'POST',
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-host-unauthorized',
+            enabled: true
+        })
+    });
+    assert.equal(unauthorizedHost.status, 401);
+
+    const setHost = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'POST',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-monitor-a',
+            enabled: true,
+            leaseMs: 30000
+        })
+    });
+    assert.equal(setHost.ok, true, JSON.stringify(setHost.payload));
+    assert.equal(setHost.payload?.ok, true);
+    assert.equal(setHost.payload?.active, true);
+    assert.equal(setHost.payload?.hostTarget?.nodeId, 'remote-fleet-monitor-a');
+    assert.equal(setHost.payload?.hostTarget?.endpoint, `127.0.0.1:${remoteHubPort}`);
+
+    const hostStatus = await fetchJson(`${baseUrl}/api/remote/status`, { token: BRIDGE_TOKEN });
+    assert.equal(hostStatus.ok, true, JSON.stringify(hostStatus.payload));
+    assert.equal(hostStatus.payload?.hostTargetActive, true);
+    assert.equal(hostStatus.payload?.hostTargetNodeId, 'remote-fleet-monitor-a');
+    assert.equal(hostStatus.payload?.hostTargetEndpoint, `127.0.0.1:${remoteHubPort}`);
+
+    const clearHostMismatch = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'DELETE',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-monitor-b'
+        })
+    });
+    assert.equal(clearHostMismatch.ok, true, JSON.stringify(clearHostMismatch.payload));
+    assert.equal(clearHostMismatch.payload?.ok, false);
+    assert.equal(clearHostMismatch.payload?.error, 'host-target-node-mismatch');
+
+    const clearHost = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+        method: 'DELETE',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            nodeId: 'remote-fleet-monitor-a'
+        })
+    });
+    assert.equal(clearHost.ok, true, JSON.stringify(clearHost.payload));
+    assert.equal(clearHost.payload?.ok, true);
+    assert.equal(clearHost.payload?.active, false);
+
     const seed = await fetchJson(`${baseUrl}/api/remote/synthetic/seed`, {
         method: 'POST',
         token: BRIDGE_TOKEN,
@@ -283,14 +382,93 @@ try {
 
     console.log(`RemoteHub HTTP smoke OK (${SYNTHETIC_COUNT} synthetic devices, bridge ${bridgePort}, remote ${remoteHubPort})`);
 } finally {
-    if (child.exitCode === null && !child.killed) {
-        child.kill('SIGTERM');
-        await Promise.race([
-            exitPromise,
-            wait(5000)
-        ]);
-        if (child.exitCode === null && !child.killed) {
-            child.kill('SIGKILL');
-        }
+    await bridge.stop();
+}
+}
+
+async function runSyntheticDisabledSmoke() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridgeToken = `${BRIDGE_TOKEN}-disabled`;
+    const pairToken = `${PAIR_TOKEN}-disabled`;
+    const bridge = spawnBridge({
+        bridgePort,
+        remoteHubPort,
+        bridgeToken,
+        pairToken,
+        syntheticFleetEnabled: false
+    });
+    const { baseUrl } = bridge;
+
+    try {
+        const status = await waitForBridge(baseUrl, bridge.details, bridge.bridgeToken);
+        assert.equal(status.started, true);
+        assert.equal(status.port, remoteHubPort);
+        assert.equal(status.pairToken, pairToken);
+        assert.equal(status.canvasPagination, 'none');
+        assert.equal(status.canvasDeviceListMode, 'all-devices');
+        assert.equal(status.hostTargetActive, false);
+
+        const seedDenied = await fetchJson(`${baseUrl}/api/remote/synthetic/seed`, {
+            method: 'POST',
+            token: bridge.bridgeToken,
+            body: JSON.stringify({
+                count: 3,
+                replace: true
+            })
+        });
+        assert.equal(seedDenied.status, 403);
+        assert.equal(seedDenied.payload?.ok, false);
+        assert.equal(seedDenied.payload?.error, 'synthetic-fleet-disabled');
+
+        const clearDenied = await fetchJson(`${baseUrl}/api/remote/synthetic`, {
+            method: 'DELETE',
+            token: bridge.bridgeToken
+        });
+        assert.equal(clearDenied.status, 403);
+        assert.equal(clearDenied.payload?.ok, false);
+        assert.equal(clearDenied.payload?.error, 'synthetic-fleet-disabled');
+
+        const devicesResult = await fetchJson(`${baseUrl}/api/remote/devices`, { token: bridge.bridgeToken });
+        assert.equal(devicesResult.ok, true, JSON.stringify(devicesResult.payload));
+        assert.equal(devicesResult.payload?.total, 0);
+        assert.equal(devicesResult.payload?.pagination, 'none');
+        assert.equal(devicesResult.payload?.canvasDeviceListMode, 'all-devices');
+        assert.equal(devicesResult.payload?.devices?.length, 0);
+
+        const emptyBatch = await fetchJson(`${baseUrl}/api/remote/tasks`, {
+            method: 'POST',
+            token: bridge.bridgeToken,
+            body: JSON.stringify({
+                allConnected: true,
+                title: 'HTTP smoke no target batch',
+                instruction: 'This should not queue because no remote devices are connected.',
+                approvalLevel: 'task-only'
+            })
+        });
+        assert.equal(emptyBatch.ok, true, JSON.stringify(emptyBatch.payload));
+        assert.equal(emptyBatch.payload?.ok, false);
+        assert.equal(emptyBatch.payload?.total, 0);
+        assert.equal(emptyBatch.payload?.queued, 0);
+        assert.equal(emptyBatch.payload?.error, 'no-target-devices');
+
+        const hostTarget = await fetchJson(`${baseUrl}/api/remote/host-target`, {
+            method: 'POST',
+            token: bridge.bridgeToken,
+            body: JSON.stringify({
+                nodeId: 'disabled-synthetic-host',
+                enabled: true
+            })
+        });
+        assert.equal(hostTarget.ok, true, JSON.stringify(hostTarget.payload));
+        assert.equal(hostTarget.payload?.ok, true);
+        assert.equal(hostTarget.payload?.active, true);
+
+        console.log(`RemoteHub HTTP safety smoke OK (synthetic disabled, bridge ${bridgePort}, remote ${remoteHubPort})`);
+    } finally {
+        await bridge.stop();
     }
 }
+
+await runSyntheticEnabledSmoke();
+await runSyntheticDisabledSmoke();