@myagentroam/marctl 0.9.121 → 0.9.122

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/marctl",
-  "version": "0.9.121",
+  "version": "0.9.122",
   "description": "MyAgentRoam command-line interface for authorized Node access.",
   "license": "Apache-2.0",
   "type": "module",

package/src/direct.mjs

@@ -27,14 +27,17 @@ export async function openDirectTerminal({
   WebSocketClass,
   nodeId,
   terminalId,
+  manifest,
   afterSequence = 0,
   timeoutMs = DIRECT_SETUP_TIMEOUT_MS,
   heartbeatMs = DIRECT_HEARTBEAT_MS,
   peerConnectionFactory,
+  onPrepared,
+  onIceConnected,
   onTransportReady,
   signal
 }) {
-  if (typeof client.getTerminalManifest !== 'function')
+  if (manifest === undefined && typeof client.getTerminalManifest !== 'function')
     throw new DirectFallbackError('DIRECT_MANIFEST_UNAVAILABLE');
 
   let live;
@@ -49,7 +52,7 @@ export async function openDirectTerminal({
   let transportNegotiationActive = true;
   let cleanupNative;
   try {
-    const manifest = await client.getTerminalManifest(nodeId);
+    manifest ??= await client.getTerminalManifest(nodeId);
     if (
       typeof manifest?.nodeGeneration !== 'string' ||
       manifest.nodeGeneration.length < 8 ||
@@ -84,7 +87,12 @@ export async function openDirectTerminal({
       peerConnectionFactory ?? ((name, options) => new native.PeerConnection(name, options));
     peer = createPeer(`marctl-${transportSessionId}`, { iceServers: [] });
 
+    // Start negotiation only after both paths finish their control-plane preparation.
+    if (onPrepared) await onPrepared();
+    if (signal?.aborted) throw new DirectFallbackError('DIRECT_RACE_CANCELLED');
+
     const transportReady = new Promise((resolve, reject) => {
+      let iceConnected = false;
       let connected = false;
       let serverOpened = false;
       let settled = false;
@@ -162,6 +170,17 @@ export async function openDirectTerminal({
         )
           finish(new DirectFallbackError('DIRECT_CONTROL_UNAVAILABLE'));
       });
+      peer.onIceStateChange((state) => {
+        if (!transportNegotiationActive || settled || iceConnected) return;
+        const normalizedState = String(state).toLowerCase();
+        if (normalizedState !== 'connected' && normalizedState !== 'completed') return;
+        iceConnected = true;
+        try {
+          onIceConnected?.();
+        } catch (error) {
+          finish(error);
+        }
+      });
       peer.onStateChange((state) => {
         if (!transportNegotiationActive || settled) return;
         const normalizedState = String(state).toLowerCase();

package/src/terminal.mjs

@@ -28,13 +28,16 @@ export async function runTerminalSession({
   let transport;
   let result;
   let primaryError;
+  let manifest;
 
   try {
-    if (
-      binary &&
-      (command === undefined || (await client.getTerminalManifest(nodeId))?.binaryTerminal !== true)
-    )
-      throw new MarctlError(translate('errors.terminalBinaryUnavailable'));
+    if (binary) {
+      if (command === undefined)
+        throw new MarctlError(translate('errors.terminalBinaryUnavailable'));
+      manifest = await client.getTerminalManifest(nodeId);
+      if (manifest?.binaryTerminal !== true)
+        throw new MarctlError(translate('errors.terminalBinaryUnavailable'));
+    }
     const created = await client.createTerminal({
       nodeId,
       ...dimensions,
@@ -47,17 +50,18 @@ export async function runTerminalSession({
     try {
       const openDirectTerminal =
         openDirectTerminalImpl ?? (await import('./direct.mjs')).openDirectTerminal;
+      if (raceConnections && manifest === undefined)
+        manifest = await client.getTerminalManifest(nodeId).catch(() => undefined);
       const directOptions = {
         client,
         WebSocketClass,
         nodeId,
         terminalId,
+        manifest,
         afterSequence: 0,
         timeoutMs: connectionTimeoutMs
       };
-      const canRace =
-        raceConnections &&
-        (await client.getTerminalManifest(nodeId).catch(() => undefined))?.deferredRelay === true;
+      const canRace = raceConnections && manifest?.deferredRelay === true;
       transport = canRace
         ? await raceTerminalConnections({
             openDirectTerminal,
@@ -137,6 +141,16 @@ async function raceTerminalConnections({
 }) {
   const abort = new AbortController();
   const relayAbort = new AbortController();
+  const preparing = new Set(['direct', 'relay']);
+  let start;
+  const preparation = new Promise((resolve) => {
+    start = resolve;
+  });
+  const prepared = (candidate) => {
+    preparing.delete(candidate);
+    if (preparing.size === 0) start();
+    return preparation;
+  };
   let selected;
   let announce;
   const first = new Promise((resolve) => {
@@ -153,12 +167,19 @@ async function raceTerminalConnections({
   const direct = openDirectTerminal({
     ...directOptions,
     signal: abort.signal,
-    onTransportReady: () => {
+    onPrepared: () => prepared('direct'),
+    onIceConnected: () => {
       if (!select('direct')) throw new Error('DIRECT_RACE_CANCELLED');
+    },
+    onTransportReady: () => {
+      if (selected !== 'direct') throw new Error('DIRECT_RACE_CANCELLED');
     }
   }).then(
     (value) => ({ value }),
-    (error) => ({ error })
+    (error) => {
+      prepared('direct');
+      return { error };
+    }
   );
   const relay = prepareRelayTransport({
     client,
@@ -167,13 +188,17 @@ async function raceTerminalConnections({
     terminalId,
     translate,
     connectionTimeoutMs,
-    signal: relayAbort.signal
+    signal: relayAbort.signal,
+    onPrepared: () => prepared('relay')
   }).then(
     (value) => {
       if (!select('relay')) value.close();
       return { value };
     },
-    (error) => ({ error })
+    (error) => {
+      prepared('relay');
+      return { error };
+    }
   );
   const winner = await Promise.race([
     first,
@@ -253,9 +278,11 @@ async function prepareRelayTransport({
   terminalId,
   translate,
   connectionTimeoutMs,
-  signal
+  signal,
+  onPrepared
 }) {
   const ticket = await client.createAttachTicket({ nodeId, terminalId });
+  if (onPrepared) await onPrepared();
   if (signal?.aborted) throw new MarctlError(translate('errors.terminalAttachConnection'));
   const socket = client.openTerminalWebSocket(WebSocketClass, {
     terminalId,