Support explicit debugger ports

npm_modules/cli/src/debugger/server.spec.ts

@@ -524,6 +524,26 @@ describe('debugger server', () => {
     expect(responseBody.logs.map(log => log.message)).toEqual(['exact application']);
   });
 
+  it('does not expose absolute log paths in filesystem error responses', async () => {
+    const logsDirectory = path.join(assetRoot, 'missing', 'logs');
+    const consoleWarn = spyOn(console, 'warn');
+    debuggerServer = await startDebuggerServer({
+      assetRoot,
+      host: '127.0.0.1',
+      logsDirectory,
+      port: await getFreePort(),
+      strictPort: true,
+    });
+
+    const result = await request(new URL('/api/runtime-logs', debuggerServer.url).toString(), GET_REQUEST_OPTIONS);
+    const responseBody = JSON.parse(result.body) as { error: string };
+
+    expect(result.statusCode).toBe(500);
+    expect(responseBody.error).toBe('A local filesystem operation failed. See the debugger server output for details.');
+    expect(result.body).not.toContain(logsDirectory);
+    expect(consoleWarn).toHaveBeenCalledWith(jasmine.stringContaining(logsDirectory));
+  });
+
   it('reads the logs directory through the shared YAML config parser', async () => {
     const testHome = path.join(assetRoot, 'home');
     const logsDirectory = path.join(testHome, 'logs#debug');

npm_modules/cli/src/debugger/server.ts

@@ -254,6 +254,22 @@ function errorPayload(error: unknown): { error: string } {
   };
 }
 
+function isFileSystemError(error: unknown): error is NodeJS.ErrnoException {
+  if (!(error instanceof Error)) return false;
+  const fileSystemError = error as NodeJS.ErrnoException;
+  return (
+    typeof fileSystemError.code === 'string' &&
+    typeof fileSystemError.path === 'string' &&
+    typeof fileSystemError.syscall === 'string'
+  );
+}
+
+function clientErrorPayload(error: unknown): { error: string } {
+  if (!isFileSystemError(error)) return errorPayload(error);
+  console.warn(`Debugger filesystem error: ${errorPayload(error).error}`);
+  return { error: 'A local filesystem operation failed. See the debugger server output for details.' };
+}
+
 function isValidSnapshotBase64(value: string): boolean {
   if (!value || value.length % 4 === 1) return false;
   const firstPaddingIndex = value.indexOf('=');
@@ -841,7 +857,7 @@ async function streamRuntimeLogs(
 
       if (nextLogs.length > 0) sendSse(response, 'logs', { logs: nextLogs });
     } catch (error) {
-      sendSse(response, 'stream-error', errorPayload(error));
+      sendSse(response, 'stream-error', clientErrorPayload(error));
     }
   }
 
@@ -899,7 +915,7 @@ async function collectClientContexts(
       try {
         contexts = await conn.listContexts(client.client_id);
       } catch (error) {
-        contextError = errorPayload(error).error;
+        contextError = clientErrorPayload(error).error;
       }
     }
 
@@ -938,7 +954,7 @@ async function inspectPort(port: number): Promise<{
       portName: portName(port),
       connected: false,
       clients: [],
-      error: errorPayload(error).error,
+      error: clientErrorPayload(error).error,
     };
   }
 }
@@ -1375,7 +1391,7 @@ async function handleApi(request: IncomingMessage, response: ServerResponse, url
 
     sendJson(response, 404, { error: `Unknown API route ${url.pathname}` });
   } catch (error) {
-    sendJson(response, error instanceof ApiRequestError ? error.statusCode : 500, errorPayload(error));
+    sendJson(response, error instanceof ApiRequestError ? error.statusCode : 500, clientErrorPayload(error));
   }
 }
 

src/valdi_modules/src/valdi/valdi_core/test/IRenderedVirtualNodeData.spec.ts

@@ -190,6 +190,39 @@ describe('IRenderedVirtualNodeData', () => {
     expect(data.component?.viewModel).toContain('Set(');
   });
 
+  it('replaces values at the maximum component debug depth with an omission marker', () => {
+    const data = createDetailedData(
+      createComponentNode(
+        {
+          level1: { level2: { level3: { level4: 'too-deep' } } },
+          sibling: 'visible',
+        },
+        {},
+      ),
+    );
+
+    expect(data.component?.viewModel).toContain('level4: ...');
+    expect(data.component?.viewModel).not.toContain('too-deep');
+    expect(data.component?.viewModel).toContain('sibling: "visible"');
+  });
+
+  it('limits arrays and objects to 50 serialized items with omission markers', () => {
+    const items = Array.from({ length: 52 }, (_value, index) => `item-${index}`);
+    const properties: Record<string, number> = {};
+    for (let index = 0; index < 52; index++) {
+      properties[`property${index}`] = index;
+    }
+
+    const data = createDetailedData(createComponentNode({ items, properties }, {}));
+
+    expect(data.component?.viewModel).toContain('"item-49"');
+    expect(data.component?.viewModel).not.toContain('"item-50"');
+    expect(data.component?.viewModel).toContain('... 2 more item(s) ...');
+    expect(data.component?.viewModel).toContain('property49: 49');
+    expect(data.component?.viewModel).not.toContain('property50: 50');
+    expect(data.component?.viewModel).toContain('... more properties ...');
+  });
+
   it('truncates one serialized component field to its character cap', () => {
     const data = createDetailedData(createComponentNode('x'.repeat(70_000), {}));
 

valdi/BUILD.bazel

@@ -598,6 +598,7 @@ kt_jvm_test(
         "@android_mvn//:org_junit_vintage_junit_vintage_engine",
     ],
     deps = [
+        ":valdi_android_support",
         ":valdi_android_test_support",
         ":valdi_java",
         "//src/valdi_modules/src/valdi/valdi_test:valdi_test_kt",

valdi/src/android_support/java/com/snap/valdi/support/AppBootstrapActivity.kt

@@ -1,6 +1,9 @@
 package com.snap.valdi.support
 
+import android.content.Intent
+import android.content.pm.ApplicationInfo
 import android.os.Bundle
+import android.util.Log
 import android.view.View
 import androidx.appcompat.app.AppCompatActivity
 
@@ -12,6 +15,12 @@ import com.snap.valdi.ValdiRuntimeManager
 import com.snap.valdi.ValdiRuntime
 import com.snap.valdi.utils.Disposable
 import com.snap.valdi.support.DefaultNavigator
+import com.snapchat.client.valdi.NativeBridge
+
+/** Intent extra used to select the Valdi debugger port for a debuggable application. */
+const val VALDI_DEBUGGER_PORT_INTENT_EXTRA = "com.snap.valdi.DEBUGGER_PORT"
+
+private const val VALDI_LOG_TAG = "Valdi"
 
 /**
   This class implements an Android activity where the root view
@@ -53,8 +62,29 @@ abstract class AppBootstrapActivity: AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
+        val debuggerPort = requestedValdiDebuggerPort(
+            intent,
+            applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0,
+        )
+        loadNativeLibrary()
+        if (debuggerPort != null) {
+            // This process-wide override intentionally persists for this debug host process. When the intent
+            // omits the extra, this block is skipped so externally configured environment state remains unchanged.
+            setDebuggerPortEnvironment(debuggerPort)
+        }
+
+        bootstrapValdiRuntime()
+    }
+
+    protected open fun loadNativeLibrary() {
         System.loadLibrary(getNativeLibName())
+    }
 
+    protected open fun setDebuggerPortEnvironment(debuggerPort: Int) {
+        NativeBridge.setDebuggerPortEnvironment(debuggerPort)
+    }
+
+    protected open fun bootstrapValdiRuntime() {
         createRuntimeManager()
         this.rootView = createAppRootView()
         setContentView(this.rootView)
@@ -106,3 +136,21 @@ abstract class AppBootstrapActivity: AppCompatActivity() {
         }
     }
 }
+
+internal fun requestedValdiDebuggerPort(intent: Intent?, debuggable: Boolean): Int? {
+    if (!debuggable || intent == null || !intent.hasExtra(VALDI_DEBUGGER_PORT_INTENT_EXTRA)) {
+        return null
+    }
+
+    val port = intent.extras?.get(VALDI_DEBUGGER_PORT_INTENT_EXTRA) as? Int
+    if (port == null || port !in 1..65535) {
+        Log.w(
+            VALDI_LOG_TAG,
+            "Ignoring invalid Valdi debugger port from intent extra " +
+                "$VALDI_DEBUGGER_PORT_INTENT_EXTRA: <redacted> (expected an integer in 1...65535)",
+        )
+        return null
+    }
+
+    return port
+}

valdi/src/java/com/snapchat/client/valdi/NativeBridge.java

@@ -4,6 +4,7 @@
 
 public class NativeBridge {
     public static native int getBuildOptions();
+    public static native void setDebuggerPortEnvironment(int debuggerPort);
     public static native long createRuntimeManager(Object mainThreadDispatcher,
                                                       Object snapDrawingFrameScheduler,
                                                       Object viewManager,

valdi/src/valdi/android/NativeBridge.cpp

@@ -62,6 +62,8 @@
 #endif
 
 #include <android/native_window_jni.h>
+#include <cstdlib>
+#include <string>
 
 inline ValdiAndroid::RuntimeWrapper* getRuntimeWrapper(jlong handle) {
     return reinterpret_cast<ValdiAndroid::RuntimeWrapper*>(handle);
@@ -148,6 +150,12 @@ jint ValdiAndroid::NativeBridge::getBuildOptions(fbjni::alias_ref<fbjni::JClass>
     return static_cast<jint>(buildOptions);
 }
 
+void ValdiAndroid::NativeBridge::setDebuggerPortEnvironment(fbjni::alias_ref<fbjni::JClass> /* clazz */,
+                                                            jint debuggerPort) {
+    const auto debuggerPortString = std::to_string(debuggerPort);
+    setenv("VALDI_DEBUGGER_PORT", debuggerPortString.c_str(), 1);
+}
+
 jlong ValdiAndroid::NativeBridge::createRuntimeManager( // NOLINT
     fbjni::alias_ref<fbjni::JClass> /* clazz */,        // NOLINT
     jobject mainThreadDispatcher,
@@ -2530,6 +2538,7 @@ jlong ValdiAndroid::NativeBridge::snapDrawingGetMaxRenderTargetSize(fbjni::alias
 void ValdiAndroid::NativeBridge::registerNatives() {
     javaClassStatic()->registerNatives({
         makeNativeMethod("getBuildOptions", ValdiAndroid::NativeBridge::getBuildOptions),
+        makeNativeMethod("setDebuggerPortEnvironment", ValdiAndroid::NativeBridge::setDebuggerPortEnvironment),
         makeNativeMethod("getAllRuntimeAttachedObjects", ValdiAndroid::NativeBridge::getAllRuntimeAttachedObjects),
         makeNativeMethod("prepareRenderBackend", ValdiAndroid::NativeBridge::prepareRenderBackend),
         makeNativeMethod("emitRuntimeManagerInitMetrics", ValdiAndroid::NativeBridge::emitRuntimeManagerInitMetrics),

valdi/src/valdi/android/NativeBridge.hpp

@@ -16,6 +16,7 @@ class NativeBridge : public fbjni::JavaClass<NativeBridge> {
     static constexpr auto kJavaDescriptor = "Lcom/snapchat/client/valdi/NativeBridge;";
 
     static jint getBuildOptions(fbjni::alias_ref<fbjni::JClass> clazz);
+    static void setDebuggerPortEnvironment(fbjni::alias_ref<fbjni::JClass> clazz, jint debuggerPort);
 
     static jobject getAllRuntimeAttachedObjects(fbjni::alias_ref<fbjni::JClass> clazz, jlong runtimeManagerHandle);
 

valdi/src/valdi/android/RuntimeManagerWrapper.cpp

@@ -104,7 +104,8 @@ RuntimeManagerWrapper::RuntimeManagerWrapper(JavaEnv env,
                                                                    _logger,
                                                                    /* enableDebuggerService */ true,
                                                                    /* disableHotReloader */ false,
-                                                                   /* isStandalone */ false);
+                                                                   /* isStandalone */ false,
+                                                                   std::nullopt);
         _runtimeManager->postInit();
         _runtimeManager->setKeepDebuggerServiceOnPause(static_cast<bool>(keepDebuggerServiceOnPause));
         _runtimeManager->setApplicationId(_applicationId);

valdi/src/valdi/ios/Bootstrap/SCValdiBootstrappingAppDelegate.m

@@ -14,10 +14,12 @@ @implementation SCValdiBootstrappingAppDelegate {
 
 - (BOOL)application:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)launchOptions
 {
-    _runtimeManager = [[SCValdiRuntimeManager alloc] init];
+    _runtimeManager = [SCValdiRuntimeManager new];
 
     [_runtimeManager updateConfiguration:^(SCValdiConfiguration* configuration) {
         configuration.allowDarkMode = YES;
+        // Bootstrap apps are local-development hosts, so keep their previous hot-reload behavior explicit.
+        configuration.enableDebuggerService = YES;
     }];
 
     id<SCValdiRuntimeProtocol> runtime = _runtimeManager.mainRuntime;

valdi/src/valdi/ios/SCValdiRuntimeManager.mm

@@ -88,6 +88,20 @@
     #endif
 }
 
+static std::optional<uint32_t> SCValdiResolveDebuggerServicePort(SCValdiConfiguration* configuration) {
+    NSInteger debuggerServicePort = configuration.debuggerServicePort;
+    if (debuggerServicePort == 0) {
+        return std::nullopt;
+    }
+
+    if (debuggerServicePort < 0 || debuggerServicePort > 65535) {
+        SCLogValdiWarning(@"Ignoring invalid Valdi debugger service port: <redacted> (expected 1...65535)");
+        return std::nullopt;
+    }
+
+    return static_cast<uint32_t>(debuggerServicePort);
+}
+
 static void updateRuntimeManagersArray(void (^callback)(NSMutableArray<NSValue *> *runtimeManagers)) {
     static dispatch_once_t onceToken;
     static NSMutableArray<NSValue *> *kAllRuntimeManagers;
@@ -204,6 +218,7 @@ - (void)_initializeIfNeeded
         _diskCache = Valdi::makeShared<Valdi::DiskCacheImpl>(resolveDocumentsDirectory());
 
         id<SCNValdiKeychain> keychainStore = SCValdiCreateKeychainStore();
+        SCValdiConfiguration *configuration = [self _getOrCreateConfiguration];
 
         _cppInstance = Valdi::makeShared<Valdi::RuntimeManager>(mainThreadDispatcher,
                                                                      [self _javaScriptBridge],
@@ -213,9 +228,10 @@ - (void)_initializeIfNeeded
                                                                      Valdi::PlatformTypeIOS,
                                                                      Valdi::ThreadQoSClassMax,
                                                                      logger,
-                                                                     /* enableDebuggerService */ true,
-                                                                     /* disableHotReloader */ false,
-                                                                     /* isStandalone */ false);
+                                                                     configuration.enableDebuggerService,
+                                                                     configuration.disableHotReloader,
+                                                                     /* isStandalone */ false,
+                                                                     SCValdiResolveDebuggerServicePort(configuration));
         _cppInstance->postInit();
         NSString *bundleIdentifier = [NSBundle mainBundle].bundleIdentifier;
         _cppInstance->setApplicationId(ValdiIOS::StringFromNSString(bundleIdentifier));

valdi/src/valdi/macos/SCValdiRuntime.mm

@@ -117,7 +117,8 @@ - (instancetype)initWithUsingTemporaryCachesDirectory:(BOOL)usingTemporaryCaches
                                                                                Valdi::strongSmallRef(&Valdi::ConsoleLogger::getLogger()),
                                                                                /* enableDebuggerService */ true,
                                                                                /* disableHotReloader */ false,
-                                                                               /* isStandalone */ true);
+                                                                               /* isStandalone */ true,
+                                                                               std::nullopt);
         _runtimeManager->postInit();
         _runtimeManager->applicationDidResume();
         _runtimeManager->registerBytesAssetLoader(cachesImageCache);

valdi/src/valdi/runtime/Debugger/DebuggerService.cpp

@@ -18,6 +18,11 @@
 
 #include "valdi_core/cpp/Utils/ContainerUtils.hpp"
 
+#include <charconv>
+#include <cstdlib>
+#include <cstring>
+#include <system_error>
+
 namespace Valdi {
 
 class DaemonClientTCPDataSender : public DaemonClientDataSender {
@@ -138,6 +143,10 @@ void DebuggerService::stop() {
     });
 }
 
+uint32_t DebuggerService::getConfiguredPort() const {
+    return _debuggerPort;
+}
+
 uint16_t DebuggerService::getBoundPort() {
     uint16_t boundPort = 0;
     _dispatchQueue->sync([&]() {
@@ -316,4 +325,43 @@ uint32_t DebuggerService::resolveDebuggerPort(bool isStandalone) {
     return isStandalone ? kStandaloneDebuggerPort : kMobileDebuggerPort;
 }
 
+DebuggerPortResolution DebuggerService::resolveDebuggerPortWithDiagnostics(
+    bool isStandalone,
+    std::optional<uint32_t> requestedPort) {
+    DebuggerPortResolution resolution{
+        resolveDebuggerPort(isStandalone),
+        std::nullopt,
+        std::nullopt,
+    };
+
+    if (requestedPort.has_value()) {
+        if (requestedPort.value() > 0 && requestedPort.value() <= 65535) {
+            resolution.port = requestedPort.value();
+            return resolution;
+        }
+        resolution.rejectedRequestedPort = requestedPort;
+    }
+
+    const char* overridePort = std::getenv("VALDI_DEBUGGER_PORT");
+    if (overridePort != nullptr) {
+        uint32_t parsedPort = 0;
+        const char* overridePortEnd = overridePort + std::strlen(overridePort);
+        const auto parseResult = std::from_chars(overridePort, overridePortEnd, parsedPort);
+        if (parseResult.ec == std::errc() && parseResult.ptr == overridePortEnd && parsedPort > 0 &&
+            parsedPort <= 65535) {
+            resolution.port = parsedPort;
+            return resolution;
+        }
+
+        if (parseResult.ec == std::errc::result_out_of_range ||
+            (parseResult.ec == std::errc() && parseResult.ptr == overridePortEnd)) {
+            resolution.environmentError = DebuggerPortEnvironmentError::OutOfRange;
+        } else {
+            resolution.environmentError = DebuggerPortEnvironmentError::Malformed;
+        }
+    }
+
+    return resolution;
+}
+
 } // namespace Valdi