@mobileaidev/ai-app-bridge 0.2.15 → 0.3.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mobileaidev/ai-app-bridge",
-  "version": "0.2.15",
+  "version": "0.3.0-rc.2",
   "description": "Desktop CLI and MCP server for AI App Bridge across Android, iOS, Flutter, WebView, and Web targets.",
   "repository": {
     "type": "git",
@@ -17,23 +17,78 @@
   },
   "files": [
     "bin/ai-app-bridge.js",
+    "bin/bridge-forward.js",
+    "bin/command-registry.js",
+    "bin/command-errors.js",
     "bin/artifact-paths.js",
+    "bin/connection-cache.js",
+    "bin/fact-codec.js",
+    "bin/fact-recorder.js",
+    "bin/fact-store.js",
+    "bin/feedback-probe.js",
+    "bin/android-uia-xml.js",
+    "bin/android-permissions.js",
+    "bin/mmap-scan-index.js",
+    "bin/segment-index.js",
+    "bin/segmented-fact-store.js",
     "bin/mcp-server.js",
+    "bin/execution-host.js",
+    "bin/device-provider.js",
+    "bin/command-discovery.js",
+    "bin/command-request.js",
+    "bin/execution-runtime.js",
+    "bin/runtime-client.js",
+    "bin/runtime-directory.js",
+    "bin/runtime-protocol.js",
+    "bin/command-router.js",
+    "bin/script",
+    "bin/intent",
+    "bin/shared-kernel",
+    "runtime/uia",
+    "bin/observation-collector.js",
     "bin/ios-provider.js",
+    "bin/ios-device-outcome.js",
+    "bin/ios-runtime-binding.js",
+    "bin/ios-execution.js",
+    "bin/target-execution.js",
     "bin/web-provider.js",
+    "bin/web",
     "skills/ai-app-bridge-use",
-    "README.md"
+    "README.md",
+    "docs/SCRIPT_AUTHORING.md",
+    "docs/EVIDENCE_ARCHIVE.md",
+    "docs/INTENT_NATIVE_EDITING.md",
+    "docs/INTENT_FOREGROUND.md",
+    "!bin/script/fake-*.js",
+    "!bin/script/p9-*.js",
+    "!bin/intent/intent-device-adapter.js",
+    "docs/COMMAND_CONTRACT.md",
+    "bin/ios-wda-port.js",
+    "bin/ios-wda-project.js",
+    "bin/ios-wda-execution.js",
+    "runtime/ios-wda",
+    "LICENSE",
+    "NOTICE",
+    "docs/RELEASE.md"
   ],
   "scripts": {
-    "check": "node -c bin/ai-app-bridge.js && node -c bin/mcp-server.js && node -c bin/ios-provider.js && node --test",
-    "test": "node --test"
+    "check": "node -c bin/ai-app-bridge.js && node -c bin/mcp-server.js && node -c bin/ios-provider.js && node --import ./test-support/ownership-test-sandbox.js --test",
+    "test": "node --import ./test-support/ownership-test-sandbox.js --test",
+    "verify:package": "node scripts/validation/verify-package.js"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "appium-webdriveragent": "^14.1.1",
+    "@mobileaidev/segmented-fact-store-native": "file:../../native/segmented-fact-store",
+    "appium-webdriveragent": "14.1.1",
     "ws": "^8.18.0"
   },
+  "bundleDependencies": [
+    "@mobileaidev/segmented-fact-store-native"
+  ],
   "publishConfig": {
     "access": "public"
+  },
+  "engines": {
+    "node": ">=26.3.0 <27"
   }
 }

package/runtime/ios-wda/AABWDABinding.h

@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Process routing identity is published inside the selected Runner's container.
+// It is not a device UDID or an authentication mechanism.
+@interface AABWDABinding : NSObject
+@property(atomic, copy, readonly) NSDictionary *identity;
+@property(atomic, readonly) BOOL ready;
++ (instancetype)shared;
+- (instancetype)initWithDirectory:(NSURL *)directory bundleId:(NSString *)bundleId
+                       processId:(NSNumber *)processId runtimeEpoch:(NSString *)runtimeEpoch;
+- (BOOL)publishPort:(NSUInteger)port error:(NSError **)error;
+- (nullable NSString *)runtimeErrorForHeaders:(NSDictionary *)headers;
+- (nullable NSString *)targetErrorForHeaders:(NSDictionary *)headers
+                               actualTarget:(NSDictionary *)target sessionId:(nullable NSString *)sessionId;
+@end
+
+NS_ASSUME_NONNULL_END

package/runtime/ios-wda/AABWDABinding.m

@@ -0,0 +1,97 @@
+#import "AABWDABinding.h"
+
+@interface AABWDABinding ()
+@property(atomic, copy, readwrite) NSDictionary *identity;
+@property(atomic, readwrite) BOOL ready;
+@property(nonatomic, strong) NSURL *directory;
+@end
+
+@implementation AABWDABinding
++ (instancetype)shared
+{
+  static AABWDABinding *value;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    NSURL *directory = [NSFileManager.defaultManager URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask].firstObject;
+    value = [[self alloc] initWithDirectory:directory bundleId:NSBundle.mainBundle.bundleIdentifier
+                                 processId:@(NSProcessInfo.processInfo.processIdentifier) runtimeEpoch:NSUUID.UUID.UUIDString];
+  });
+  return value;
+}
+
+- (instancetype)initWithDirectory:(NSURL *)directory bundleId:(NSString *)bundleId
+                       processId:(NSNumber *)processId runtimeEpoch:(NSString *)runtimeEpoch
+{
+  self = [super init];
+  if (self) {
+    _directory = directory;
+    _identity = @{ @"schemaVersion": @"aab.ios-wda/v1", @"bundleId": bundleId,
+                   @"runtimeEpoch": runtimeEpoch, @"processId": processId, @"port": @0 };
+  }
+  return self;
+}
+
+- (BOOL)publishPort:(NSUInteger)port error:(NSError **)error
+{
+  self.ready = NO;
+  if (port < 1 || port > 65535) {
+    if (error) *error = [NSError errorWithDomain:@"AABWDABinding" code:1 userInfo:@{NSLocalizedDescriptionKey:@"Invalid WDA port"}];
+    return NO;
+  }
+  NSMutableDictionary *identity = self.identity.mutableCopy;
+  identity[@"port"] = @(port);
+  self.identity = identity.copy;
+  NSMutableDictionary *descriptor = identity.mutableCopy;
+  descriptor[@"ok"] = @YES;
+  NSData *data = [NSJSONSerialization dataWithJSONObject:descriptor options:NSJSONWritingSortedKeys error:error];
+  if (!data || ![NSFileManager.defaultManager createDirectoryAtURL:self.directory withIntermediateDirectories:YES attributes:nil error:error]) return NO;
+  self.ready = [data writeToURL:[self.directory URLByAppendingPathComponent:@"ai_app_bridge_wda.json"] options:NSDataWritingAtomic error:error];
+  return self.ready;
+}
+
+- (nullable NSDictionary *)normalizedHeaders:(NSDictionary *)headers
+{
+  NSMutableDictionary *values = [NSMutableDictionary dictionary];
+  for (id key in headers) {
+    if (![key isKindOfClass:NSString.class] || ![headers[key] isKindOfClass:NSString.class]) return nil;
+    NSString *name = [key lowercaseString];
+    if (values[name]) return nil;
+    values[name] = headers[key];
+  }
+  return values.copy;
+}
+
+- (nullable NSString *)runtimeErrorForHeaders:(NSDictionary *)headers
+{
+  if (!self.ready) return @"ios_wda_descriptor_not_ready";
+  NSDictionary *values = [self normalizedHeaders:headers];
+  if (!values) return @"invalid_ios_wda_headers";
+  NSDictionary *identity = self.identity;
+  NSDictionary *expected = @{
+    @"x-aab-wda-schema": identity[@"schemaVersion"],
+    @"x-aab-wda-bundle-id": identity[@"bundleId"],
+    @"x-aab-wda-runtime-epoch": identity[@"runtimeEpoch"],
+    @"x-aab-wda-process-id": [identity[@"processId"] stringValue],
+    @"x-aab-wda-port": [identity[@"port"] stringValue],
+  };
+  for (NSString *key in expected) {
+    if (![values[key] isEqual:expected[key]]) return @"ios_wda_binding_mismatch";
+  }
+  return nil;
+}
+
+- (nullable NSString *)targetErrorForHeaders:(NSDictionary *)headers
+                               actualTarget:(NSDictionary *)target sessionId:(nullable NSString *)sessionId
+{
+  NSDictionary *values = [self normalizedHeaders:headers];
+  if (!values) return @"invalid_ios_wda_headers";
+  NSString *bundleId = target[@"bundleId"];
+  NSNumber *processId = target[@"processId"];
+  if (![bundleId isKindOfClass:NSString.class] || !bundleId.length || ![processId isKindOfClass:NSNumber.class] || processId.longLongValue <= 0)
+    return @"ios_wda_foreground_unavailable";
+  if (![values[@"x-aab-wda-target-bundle-id"] isEqual:bundleId]
+      || ![values[@"x-aab-wda-target-process-id"] isEqual:processId.stringValue]) return @"ios_wda_target_changed";
+  if (sessionId && ![values[@"x-aab-wda-session-id"] isEqual:sessionId]) return @"ios_wda_session_changed";
+  return nil;
+}
+@end

package/runtime/ios-wda/AABWDAExecution.h

@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+#import "AABWDAReceiptStore.h"
+
+NS_ASSUME_NONNULL_BEGIN
+@class AABWDATask;
+typedef void (^AABWDAReply)(NSDictionary *);
+typedef void (^AABWDAStart)(AABWDATask *);
+
+// The execution state is independent of the WDA main UI queue. A task must get
+// permission immediately before each event, and finish only from original callbacks.
+@interface AABWDATask : NSObject
+@property(nonatomic, copy, readonly) NSDictionary *body;
+@property(nonatomic, copy, readonly) NSDictionary *target;
+- (nullable NSString *)permission;
+- (void)finish:(NSDictionary *)outcome;
+- (void)unresolved:(NSString *)reason;
+@end
+
+@interface AABWDAExecution : NSObject
+- (instancetype)initWithStore:(AABWDAReceiptStore *)store epoch:(NSString *)epoch;
+- (void)submit:(NSDictionary *)body target:(NSDictionary *)target start:(AABWDAStart)start reply:(AABWDAReply)reply;
+- (NSDictionary *)cancel:(NSString *)actionId epoch:(NSString *)epoch;
+- (NSDictionary *)status;
+- (NSDictionary *)result:(NSString *)actionId epoch:(NSString *)epoch cursor:(nullable NSString *)cursor;
+@end
+NS_ASSUME_NONNULL_END

package/runtime/ios-wda/AABWDAExecution.m

@@ -0,0 +1,172 @@
+#import "AABWDAExecution.h"
+
+static NSString *const AABWDASchema = @"aab.wda-execution/v1";
+static NSDictionary *AABWDAFailure(NSString *code)
+{
+  return @{@"ok": @NO, @"error": code, @"dispatched": @NO, @"ambiguous": @NO};
+}
+static BOOL AABWDAText(id value)
+{
+  return [value isKindOfClass:NSString.class] && [value length] > 0 && [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding] <= 256;
+}
+
+@interface AABWDATask ()
+@property(nonatomic, copy, readwrite) NSDictionary *body;
+@property(nonatomic, copy, readwrite) NSDictionary *target;
+@property(nonatomic, weak) AABWDAExecution *owner;
+@property(nonatomic, copy) NSDictionary *identity;
+@property(nonatomic) NSTimeInterval deadline;
+@property(nonatomic) BOOL issued;
+@property(nonatomic, copy, nullable) NSString *stopReason;
+@property(nonatomic, copy, nullable) NSDictionary *candidate;
+@property(nonatomic, copy, nullable) AABWDAReply reply;
+@end
+
+@interface AABWDAExecution ()
+- (nullable NSString *)permission:(AABWDATask *)task;
+- (void)finish:(AABWDATask *)task outcome:(NSDictionary *)outcome;
+- (void)stop:(AABWDATask *)task reason:(NSString *)reason;
+@end
+@implementation AABWDATask
+- (NSString *)permission { return self.owner ? [self.owner permission:self] : @"ios_wda_action_not_active"; }
+- (void)finish:(NSDictionary *)outcome { [self.owner finish:self outcome:outcome]; }
+- (void)unresolved:(NSString *)reason { AABWDAExecution *owner = self.owner; @synchronized (owner) { [owner stop:self reason:reason]; } }
+@end
+
+@implementation AABWDAExecution {
+  AABWDAReceiptStore *_store;
+  NSString *_epoch;
+  AABWDATask *_active;
+  NSString *_lastId;
+}
+- (instancetype)initWithStore:(AABWDAReceiptStore *)store epoch:(NSString *)epoch
+{
+  self = [super init];
+  if (self) { _store = store; _epoch = epoch.copy; }
+  return self;
+}
+- (NSDictionary *)pending:(AABWDATask *)task code:(NSString *)code
+{
+  NSMutableDictionary *result = task.identity.mutableCopy;
+  [result addEntriesFromDictionary:@{@"ok": @NO, @"error": code, @"settled": @NO, @"dispatched": NSNull.null, @"ambiguous": @YES}];
+  return result;
+}
+- (void)reply:(AABWDATask *)task value:(NSDictionary *)value
+{
+  AABWDAReply reply = task.reply; task.reply = nil;
+  // Response serialization can never block the execution lock or re-enter it.
+  if (reply) dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ reply(value); });
+}
+- (void)persist:(AABWDATask *)task
+{
+  if (_active != task || !task.candidate) return;
+  NSDictionary *receipt = [_store commit:task.candidate];
+  if (!receipt) { [self reply:task value:[self pending:task code:@"ios_wda_completion_store_unavailable"]]; return; }
+  _lastId = task.identity[@"actionId"]; _active = nil;
+  [self reply:task value:task.candidate];
+}
+- (void)stop:(AABWDATask *)task reason:(NSString *)reason
+{
+  if (_active != task) return;
+  if (task.candidate) { [self persist:task]; return; }
+  if (task.stopReason) return;
+  task.stopReason = reason;
+  if (!task.issued) {
+    [self finish:task outcome:AABWDAFailure(task.stopReason)];
+  } else {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1500 * NSEC_PER_MSEC), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+      @synchronized (self) { if (self->_active == task) [self reply:task value:[self pending:task code:task.stopReason]]; }
+    });
+  }
+}
+- (void)submit:(NSDictionary *)body target:(NSDictionary *)target start:(AABWDAStart)start reply:(AABWDAReply)reply
+{
+  @synchronized (self) {
+    NSDictionary *execution = body[@"execution"];
+    id timeout = [execution isKindOfClass:NSDictionary.class] ? execution[@"timeoutMs"] : nil;
+    NSSet *fields = [NSSet setWithArray:@[@"schemaVersion", @"actionId", @"runtimeEpoch", @"timeoutMs"]];
+    if (![execution isKindOfClass:NSDictionary.class] || ![[NSSet setWithArray:execution.allKeys] isEqual:fields]
+        || ![execution[@"schemaVersion"] isEqual:AABWDASchema] || !AABWDAText(execution[@"actionId"])
+        || ![body[@"actionId"] isEqual:execution[@"actionId"]] || ![execution[@"runtimeEpoch"] isEqual:_epoch]
+        || ![timeout isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)timeout) == CFBooleanGetTypeID()
+        || [timeout doubleValue] != [timeout longLongValue] || [timeout longLongValue] < 1 || [timeout longLongValue] > INT32_MAX) {
+      reply(AABWDAFailure(@"invalid_ios_wda_execution")); return;
+    }
+    if (!_store.ready) { reply(AABWDAFailure(@"ios_wda_completion_store_unavailable")); return; }
+    if (_active) { reply(AABWDAFailure(@"ios_wda_action_busy")); return; }
+    if ([_lastId isEqual:execution[@"actionId"]]) { reply(AABWDAFailure(@"ios_wda_action_id_reused")); return; }
+    AABWDATask *task = [AABWDATask new];
+    task.owner = self; task.body = body.copy; task.target = target.copy; task.reply = reply;
+    task.deadline = NSProcessInfo.processInfo.systemUptime + [timeout doubleValue] / 1000;
+    task.identity = @{@"schemaVersion": AABWDASchema, @"actionId": execution[@"actionId"], @"runtimeEpoch": _epoch};
+    _active = task;
+    __weak AABWDATask *weakTask = task;
+    __weak AABWDAExecution *weakSelf = self;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, [timeout longLongValue] * NSEC_PER_MSEC), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+      AABWDAExecution *owner = weakSelf; AABWDATask *pending = weakTask;
+      if (owner && pending) @synchronized (owner) { [owner stop:pending reason:@"ios_wda_action_timeout"]; }
+    });
+    dispatch_async(dispatch_get_main_queue(), ^{
+      @synchronized (self) { if (self->_active != task || task.candidate || task.stopReason) return; }
+      start(task);
+    });
+  }
+}
+- (NSString *)permission:(AABWDATask *)task
+{
+  @synchronized (self) {
+    if (_active != task || task.candidate) return @"ios_wda_action_not_active";
+    if (NSProcessInfo.processInfo.systemUptime >= task.deadline) [self stop:task reason:@"ios_wda_action_timeout"];
+    if (_active != task || task.stopReason) return task.stopReason ?: @"ios_wda_action_not_active";
+    task.issued = YES;
+    return nil;
+  }
+}
+- (void)finish:(AABWDATask *)task outcome:(NSDictionary *)outcome
+{
+  @synchronized (self) {
+    if (_active != task || task.candidate) return;
+    if (![outcome[@"ok"] isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)outcome[@"ok"]) != CFBooleanGetTypeID()
+        || (![outcome[@"ok"] boolValue] && !AABWDAText(outcome[@"error"]))) return;
+    NSMutableDictionary *result = outcome.mutableCopy;
+    if (task.stopReason) { result[@"ok"] = @NO; result[@"error"] = task.stopReason; }
+    result[@"actionId"] = task.identity[@"actionId"]; result[@"runtimeEpoch"] = _epoch;
+    result[@"settled"] = @YES; result[@"dispatched"] = @(task.issued); result[@"ambiguous"] = @NO;
+    NSMutableDictionary *execution = task.identity.mutableCopy;
+    execution[@"settled"] = @YES; execution[@"target"] = task.target;
+    result[@"execution"] = execution;
+    NSData *bytes = [NSJSONSerialization isValidJSONObject:result]
+      ? [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingSortedKeys error:NULL] : nil;
+    if (!bytes || bytes.length > 64 * 1024) {
+      result = [@{@"ok": @NO, @"error": @"ios_wda_invalid_result", @"execution": execution,
+        @"actionId": task.identity[@"actionId"], @"runtimeEpoch": _epoch, @"settled": @YES,
+        @"dispatched": @(task.issued), @"ambiguous": @NO} mutableCopy];
+    }
+    task.candidate = result.copy;
+    [self persist:task];
+  }
+}
+- (NSDictionary *)cancel:(NSString *)actionId epoch:(NSString *)epoch
+{
+  @synchronized (self) {
+    AABWDATask *task = _active;
+    if (task && [task.identity[@"actionId"] isEqual:actionId] && [task.identity[@"runtimeEpoch"] isEqual:epoch]) {
+      [self stop:task reason:@"ios_wda_action_cancelled"];
+      if (_active == task) return [self pending:task code:@"ios_wda_action_cancel_pending"];
+    }
+    return [_store lookupAction:actionId epoch:epoch cursor:nil];
+  }
+}
+- (NSDictionary *)result:(NSString *)actionId epoch:(NSString *)epoch cursor:(NSString *)cursor
+{
+  return [_store lookupAction:actionId epoch:epoch cursor:cursor];
+}
+- (NSDictionary *)status
+{
+  @synchronized (self) {
+    return @{@"ok": @YES, @"executionSchema": AABWDASchema, @"ready": @(_store.ready),
+      @"active": _active ? @{@"identity": _active.identity, @"target": _active.target, @"permissionIssued": @(_active.issued),
+          @"persistencePending": @(_active.candidate != nil), @"stopReason": _active.stopReason ?: NSNull.null} : NSNull.null};
+  }
+}
+@end

package/runtime/ios-wda/AABWDAIntegration.h

@@ -0,0 +1,71 @@
+// Included once by the prepared FBWebServer translation unit. The upstream
+// package remains untouched; prepare-ios-wda records every source transformation.
+#import "AABWDABinding.m"
+#import "FBCommandHandler.h"
+#import "FBConfiguration.h"
+#import "FBResponseJSONPayload.h"
+#import "FBRouteRequest.h"
+#import "FBSession.h"
+#import "XCUIApplication+FBHelpers.h"
+#import "XCUIApplication+FBQuiescence.h"
+#import "XCUIApplication.h"
+
+static NSDictionary *AABWDASessionTarget;
+
+static NSDictionary *AABWDAForeground(void)
+{
+  XCUIApplication *app = XCUIApplication.fb_activeApplication;
+  return app.bundleID && app.processID > 0
+    ? @{ @"bundleId": app.bundleID, @"processId": @(app.processID) } : @{};
+}
+
+static id<FBResponsePayload> AABWDAReject(NSString *code)
+{
+  return [[FBResponseJSONPayload alloc] initWithDictionary:@{
+    @"wdaBinding": AABWDABinding.shared.identity, @"sessionId": NSNull.null,
+    @"value": @{ @"error": code, @"message": code, @"dispatched": @NO, @"ambiguous": @NO }
+  } httpStatusCode:409];
+}
+
+// Called by WDA on its main route queue immediately before mounting the route.
+// Session/foreground checks also protect reads: reading a tree cannot launch
+// an App, replace a session, or silently observe another foreground process.
+static NSString *AABWDAAdmission(FBRoute *route, NSDictionary *headers, NSDictionary *parameters, NSData *body)
+{
+  NSString *error = [AABWDABinding.shared runtimeErrorForHeaders:headers];
+  if (error) return error;
+  if (body.length > 4 * 1024 * 1024) return @"ios_wda_request_too_large";
+  if (body.length && ![[NSJSONSerialization JSONObjectWithData:body options:0 error:NULL] isKindOfClass:NSDictionary.class])
+    return @"invalid_ios_wda_json";
+  if ([route.path isEqual:@"/status"] || ([route.path isEqual:@"/aab/session"] && [route.verb isEqual:@"GET"])) return nil;
+  if (![route.path hasPrefix:@"/session/:sessionID/"]) return @"ios_wda_route_unsupported";
+  FBSession *session = FBSession.activeSession;
+  if (!session || !AABWDASessionTarget || ![session.identifier isEqual:AABWDASessionTarget[@"sessionId"]]) return @"ios_wda_session_required";
+  if (![parameters[@"sessionID"] isEqual:session.identifier]) return @"ios_wda_session_changed";
+  NSDictionary *foreground = AABWDAForeground();
+  if (![foreground[@"bundleId"] isEqual:AABWDASessionTarget[@"bundleId"]]
+      || ![foreground[@"processId"] isEqual:AABWDASessionTarget[@"processId"]]) return @"ios_wda_target_changed";
+  error = [AABWDABinding.shared targetErrorForHeaders:headers actualTarget:foreground sessionId:session.identifier];
+  if (error) return error;
+  NSSet *allowed = [NSSet setWithArray:@[
+    @"GET /session/:sessionID/source", @"POST /session/:sessionID/elements"
+  ]];
+  return [allowed containsObject:[NSString stringWithFormat:@"%@ %@", route.verb, route.path]] ? nil : @"ios_wda_route_unsupported";
+}
+
+@interface AABWDACommands : NSObject <FBCommandHandler>
+@end
+
+#import "AABWDAManagedRoutes.h"
+@implementation AABWDACommands
++ (NSArray *)routes
+{
+  return @[
+    [[FBRoute GET:@"/aab/session"].withoutSession respondWithTarget:self action:@selector(status:)]
+  ];
+}
++ (id<FBResponsePayload>)status:(FBRouteRequest *)request
+{
+  return FBResponseWithObject(@{ @"foreground": AABWDAForeground(), @"session": AABWDASessionTarget ?: NSNull.null });
+}
+@end