AutoMobile

Instructions

Implementation Reference

• src/server/deepLinkTools.ts:108-114 (registration)

  Registers the "getDeepLinks" MCP tool with ToolRegistry, specifying name, description, input schema, execution handler, and progress support flag.

  ToolRegistry.registerDeviceAware(
    "getDeepLinks",
    "Query available deep links and intent filters for an Android application",
    getDeepLinksSchema,
    getDeepLinksHandler,
    false // Does not support progress notifications
  );

• src/server/deepLinkTools.ts:40-60 (handler)

  The primary handler function for the getDeepLinks tool, instantiates GetDeepLinks class, calls execute, formats response as JSON, and handles errors.

  const getDeepLinksHandler = async (device: BootedDevice, args: GetDeepLinksArgs) => {
    try {
      const getDeepLinks = new GetDeepLinks(device);
      const result = await getDeepLinks.execute(args.appId);
  
      return createJSONToolResponse({
        message: `Discovered deep links for app ${args.appId}`,
        success: result.success,
        appId: result.appId,
        schemes: result.deepLinks.schemes,
        hosts: result.deepLinks.hosts,
        intentFilters: result.deepLinks.intentFilters,
        supportedMimeTypes: result.deepLinks.supportedMimeTypes,
        error: result.error,
        rawOutput: result.rawOutput
      });
    } catch (error) {
      logger.error(`[getDeepLinks] Failed to get deep links: ${error}`);
      throw new ActionableError(`Failed to get deep links: ${error}`);
    }
  };

• src/server/deepLinkTools.ts:11-13 (schema)

  Zod schema defining the input parameters for the getDeepLinks tool: appId (string).

  export const getDeepLinksSchema = z.object({
    appId: z.string().describe("Android app package ID to query for deep links"),
  });

• src/features/utility/GetDeepLinks.ts:5-46 (helper)

  GetDeepLinks class providing the core execute method that delegates to DeepLinkManager for querying and parsing deep links, with input validation and error handling.

  export class GetDeepLinks {
    private deepLinkManager: DeepLinkManager;
  
    constructor(device: BootedDevice | null = null) {
      this.deepLinkManager = new DeepLinkManager(device);
    }
  
    /**
     * Execute deep link discovery for an application
     * @param appId - The application package ID to query
     * @returns Promise with deep link discovery results
     */
    async execute(appId: string): Promise<DeepLinkResult> {
      try {
        logger.info(`[GetDeepLinks] Starting deep link discovery for app: ${appId}`);
  
        if (!appId || appId.trim().length === 0) {
          throw new Error("App ID cannot be empty");
        }
  
        const result = await this.deepLinkManager.getDeepLinks(appId);
  
        logger.info(`[GetDeepLinks] Deep link discovery completed for ${appId}. Found ${result.deepLinks.schemes.length} schemes and ${result.deepLinks.hosts.length} hosts`);
  
        return result;
      } catch (error) {
        logger.error(`[GetDeepLinks] Failed to get deep links for ${appId}: ${error}`);
  
        return {
          success: false,
          appId,
          deepLinks: {
            schemes: [],
            hosts: [],
            intentFilters: [],
            supportedMimeTypes: []
          },
          error: error instanceof Error ? error.message : String(error)
        };
      }
    }
  }

• src/utils/deepLinkManager.ts:35-67 (helper)

  DeepLinkManager.getDeepLinks method executes 'adb shell dumpsys package' command and calls parser to extract schemes, hosts, intent filters, and MIME types.

  async getDeepLinks(appId: string): Promise<DeepLinkResult> {
    try {
      logger.info(`[DeepLinkManager] Querying deep links for app: ${appId}`);
  
      // Use dumpsys package to get detailed package information including intent filters
      const packageInfoResult = await this.adbUtils.executeCommand(
        `shell dumpsys package ${appId}`
      );
  
      // Parse the results
      const deepLinks = this.parsePackageDumpsysOutput(appId, packageInfoResult.stdout);
  
      return {
        success: true,
        appId,
        deepLinks,
        rawOutput: packageInfoResult.stdout
      };
    } catch (error) {
      logger.error(`[DeepLinkManager] Failed to get deep links for ${appId}: ${error}`);
      return {
        success: false,
        appId,
        deepLinks: {
          schemes: [],
          hosts: [],
          intentFilters: [],
          supportedMimeTypes: []
        },
        error: error instanceof Error ? error.message : String(error)
      };
    }
  }